lawkit-python 2.1.0__py3-none-any.whl

lawkit/__init__.py

@@ -0,0 +1,60 @@
+"""
+lawkit: Python wrapper for the lawkit CLI tool
+
+This package provides a Python interface to the lawkit CLI tool for statistical
+law analysis including Benford's Law, Pareto principle, Zipf's Law, Normal distribution,
+and Poisson distribution analysis. Perfect for fraud detection, data quality assessment,
+and statistical analysis.
+"""
+
+from .lawkit import (
+    analyze_benford,
+    analyze_pareto,
+    analyze_zipf,
+    analyze_normal,
+    analyze_poisson,
+    compare_laws,
+    generate_data,
+    analyze_string,
+    is_lawkit_available,
+    get_version,
+    selftest,
+    LawkitOptions,
+    LawkitResult,
+    LawkitError,
+    Format,
+    OutputFormat,
+    LawType,
+)
+
+# For backward compatibility and convenience
+from .compat import run_lawkit
+
+__version__ = "2.1.0"
+__all__ = [
+    # Main analysis functions
+    "analyze_benford",
+    "analyze_pareto", 
+    "analyze_zipf",
+    "analyze_normal",
+    "analyze_poisson",
+    "compare_laws",
+    
+    # Utility functions
+    "generate_data",
+    "analyze_string",
+    "is_lawkit_available",
+    "get_version",
+    "selftest",
+    
+    # Types and classes
+    "LawkitOptions",
+    "LawkitResult",
+    "LawkitError",
+    "Format",
+    "OutputFormat", 
+    "LawType",
+    
+    # Backward compatibility
+    "run_lawkit",
+]

lawkit/compat.py

@@ -0,0 +1,204 @@
+"""
+Backward compatibility module for lawkit-python
+
+This module provides compatibility functions for users migrating from 
+other statistical analysis tools or expecting different API patterns.
+"""
+
+import subprocess
+import platform
+from pathlib import Path
+from typing import List, Union
+
+
+class LawkitProcess:
+    """Compatibility class that mimics subprocess.CompletedProcess"""
+    def __init__(self, returncode: int, stdout: str, stderr: str):
+        self.returncode = returncode
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+def run_lawkit(args: List[str], input_data: Union[str, None] = None) -> LawkitProcess:
+    """
+    Run lawkit command with arguments (legacy compatibility function)
+    
+    Args:
+        args: Command line arguments (without 'lawkit' prefix)
+        input_data: Optional input data to pass via stdin
+        
+    Returns:
+        LawkitProcess object with returncode, stdout, stderr
+        
+    Examples:
+        >>> result = run_lawkit(["benf", "data.csv"])
+        >>> if result.returncode == 0:
+        ...     print("Analysis successful")
+        ...     print(result.stdout)
+        ... else:
+        ...     print("Analysis failed")
+        ...     print(result.stderr)
+        
+        >>> # With input data
+        >>> csv_data = "amount\\n123\\n456\\n789"
+        >>> result = run_lawkit(["benf", "-"], input_data=csv_data)
+    """
+    # Get the path to the lawkit binary
+    package_dir = Path(__file__).parent.parent.parent
+    binary_name = "lawkit.exe" if platform.system() == "Windows" else "lawkit"
+    local_binary_path = package_dir / "bin" / binary_name
+    
+    if local_binary_path.exists():
+        lawkit_path = str(local_binary_path)
+    else:
+        lawkit_path = "lawkit"
+    
+    try:
+        # Run the command
+        result = subprocess.run(
+            [lawkit_path] + args,
+            input=input_data,
+            capture_output=True,
+            text=True,
+            timeout=300  # 5 minute timeout
+        )
+        
+        return LawkitProcess(
+            returncode=result.returncode,
+            stdout=result.stdout,
+            stderr=result.stderr
+        )
+        
+    except subprocess.TimeoutExpired:
+        return LawkitProcess(
+            returncode=-1,
+            stdout="",
+            stderr="Command timed out after 5 minutes"
+        )
+    except FileNotFoundError:
+        return LawkitProcess(
+            returncode=-1,
+            stdout="",
+            stderr="lawkit command not found. Please install lawkit CLI tool."
+        )
+    except Exception as e:
+        return LawkitProcess(
+            returncode=-1,
+            stdout="",
+            stderr=f"Error running lawkit: {e}"
+        )
+
+
+def run_benford_analysis(file_path: str, **kwargs) -> LawkitProcess:
+    """
+    Legacy function for Benford's Law analysis
+    
+    Args:
+        file_path: Path to input file
+        **kwargs: Additional options (format, output, etc.)
+        
+    Returns:
+        LawkitProcess object
+        
+    Examples:
+        >>> result = run_benford_analysis("data.csv", format="csv", output="json")
+    """
+    args = ["benf", file_path]
+    
+    if "format" in kwargs:
+        args.extend(["--format", kwargs["format"]])
+    
+    if "output" in kwargs:
+        args.extend(["--output", kwargs["output"]])
+    
+    if "min_count" in kwargs:
+        args.extend(["--min-count", str(kwargs["min_count"])])
+    
+    if "threshold" in kwargs:
+        args.extend(["--threshold", str(kwargs["threshold"])])
+    
+    if kwargs.get("verbose", False):
+        args.append("--verbose")
+    
+    if kwargs.get("optimize", False):
+        args.append("--optimize")
+    
+    return run_lawkit(args)
+
+
+def run_pareto_analysis(file_path: str, **kwargs) -> LawkitProcess:
+    """
+    Legacy function for Pareto principle analysis
+    
+    Args:
+        file_path: Path to input file
+        **kwargs: Additional options
+        
+    Returns:
+        LawkitProcess object
+        
+    Examples:
+        >>> result = run_pareto_analysis("sales.csv", gini_coefficient=True)
+    """
+    args = ["pareto", file_path]
+    
+    if "format" in kwargs:
+        args.extend(["--format", kwargs["format"]])
+    
+    if "output" in kwargs:
+        args.extend(["--output", kwargs["output"]])
+    
+    if kwargs.get("gini_coefficient", False):
+        args.append("--gini-coefficient")
+    
+    if "percentiles" in kwargs:
+        args.extend(["--percentiles", kwargs["percentiles"]])
+    
+    if kwargs.get("business_analysis", False):
+        args.append("--business-analysis")
+    
+    if kwargs.get("verbose", False):
+        args.append("--verbose")
+    
+    return run_lawkit(args)
+
+
+def check_lawkit_installation() -> bool:
+    """
+    Check if lawkit is properly installed
+    
+    Returns:
+        True if lawkit is available, False otherwise
+        
+    Examples:
+        >>> if not check_lawkit_installation():
+        ...     print("Please install lawkit first")
+        ...     exit(1)
+    """
+    result = run_lawkit(["--version"])
+    return result.returncode == 0
+
+
+def get_lawkit_help(subcommand: str = None) -> str:
+    """
+    Get help text for lawkit or a specific subcommand
+    
+    Args:
+        subcommand: Optional subcommand name
+        
+    Returns:
+        Help text as string
+        
+    Examples:
+        >>> help_text = get_lawkit_help()
+        >>> print(help_text)
+        
+        >>> benf_help = get_lawkit_help("benf")
+        >>> print(benf_help)
+    """
+    if subcommand:
+        result = run_lawkit([subcommand, "--help"])
+    else:
+        result = run_lawkit(["--help"])
+    
+    return result.stdout if result.returncode == 0 else result.stderr

lawkit/installer.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""Binary installer for lawkit."""
+
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib.request
+import zipfile
+from pathlib import Path
+
+LAWKIT_VERSION = "2.1.0"
+
+
+def get_platform_info():
+    """Get platform-specific download information."""
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    
+    if system == "windows":
+        return "lawkit-windows-x86_64.zip", "lawkit.exe"
+    elif system == "darwin":
+        if machine in ["arm64", "aarch64"]:
+            return "lawkit-macos-aarch64.tar.gz", "lawkit"
+        else:
+            return "lawkit-macos-x86_64.tar.gz", "lawkit"
+    elif system == "linux":
+        if machine in ["arm64", "aarch64"]:
+            return "lawkit-linux-aarch64.tar.gz", "lawkit"
+        else:
+            return "lawkit-linux-x86_64.tar.gz", "lawkit"
+    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 lawkit 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 lawkit 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("lawkit 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/lawkit/releases/download/v{LAWKIT_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"✅ lawkit binary installed successfully at {binary_path}")
+        
+        # Test the binary
+        try:
+            result = subprocess.run([str(binary_path), "--version"], 
+                                  capture_output=True, text=True, timeout=10)
+            if result.returncode == 0:
+                print(f"✅ lawkit binary is working correctly")
+                print(f"   Version: {result.stdout.strip()}")
+            else:
+                print(f"⚠️  lawkit binary installed but version check failed")
+        except (subprocess.TimeoutExpired, subprocess.CalledProcessError) as e:
+            print(f"⚠️  lawkit binary installed but verification failed: {e}")
+        
+        return 0
+        
+    except Exception as error:
+        print(f"❌ Failed to download lawkit binary: {error}")
+        print("You may need to install lawkit manually from: https://github.com/kako-jun/lawkit/releases")
+        print("Or build from source: https://github.com/kako-jun/lawkit")
+        # Don't fail the installation, just warn
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())