lawkit-python 2.1.1__tar.gz → 2.3.0__tar.gz

{lawkit_python-2.1.1 → lawkit_python-2.3.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: lawkit-python
-Version: 2.1.1
+Version: 2.3.0
 Summary: Python wrapper for lawkit - Statistical law analysis toolkit for fraud detection and data quality assessment
 Project-URL: Homepage, https://github.com/kako-jun/lawkit
 Project-URL: Repository, https://github.com/kako-jun/lawkit
 Project-URL: Issues, https://github.com/kako-jun/lawkit/issues
 Project-URL: Documentation, https://github.com/kako-jun/lawkit/tree/main/docs
-Author-email: kako-jun <kako.jun.42@gmail.com>
+Author: kako-jun
 License-Expression: MIT
 Keywords: anomaly-detection,audit,benford,compliance,data-quality,forensic-accounting,fraud-detection,normal,outlier-detection,pareto,poisson,statistical-analysis,statistics,zipf
 Classifier: Development Status :: 4 - Beta
@@ -31,11 +31,9 @@ Provides-Extra: dev
 Requires-Dist: black; extra == 'dev'
 Requires-Dist: isort; extra == 'dev'
 Requires-Dist: mypy; extra == 'dev'
-Requires-Dist: pytest-asyncio; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest>=6.0; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
-Requires-Dist: types-requests; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # lawkit-python
@@ -62,7 +60,7 @@ print(result)
 # Get structured JSON output
 json_result = lawkit.analyze_benford(
     'accounting.csv',
-    lawkit.LawkitOptions(format='csv', output='json')
+    lawkit.LawkitOptions(format='json')
 )
 print(f"Risk level: {json_result.risk_level}")
 print(f"P-value: {json_result.p_value}")
@@ -70,7 +68,7 @@ print(f"P-value: {json_result.p_value}")
 # Check if data follows Pareto principle (80/20 rule)
 pareto_result = lawkit.analyze_pareto(
     'sales_data.csv',
-    lawkit.LawkitOptions(output='json', gini_coefficient=True)
+    lawkit.LawkitOptions(format='json', gini_coefficient=True)
 )
 print(f"Gini coefficient: {pareto_result.gini_coefficient}")
 print(f"80/20 concentration: {pareto_result.concentration_80_20}")
@@ -159,13 +157,27 @@ if normal_result.p_value < 0.05:
     if normal_result.outliers:
         print(f"Found {len(normal_result.outliers)} outliers")
 
-# Multi-law comparison
-comparison = lawkit.compare_laws(
+# Multi-law analysis
+analysis = lawkit.analyze_laws(
     'complex_dataset.csv',
-    lawkit.LawkitOptions(output='json')
+    lawkit.LawkitOptions(format='json', laws='benf,pareto,zipf')
 )
-print(f"Best fitting law: {comparison.data.get('best_law')}")
-print(f"Overall risk level: {comparison.risk_level}")
+print(f"Analysis results: {analysis.data}")
+print(f"Overall risk level: {analysis.risk_level}")
+
+# Data validation
+validation = lawkit.validate_laws(
+    'complex_dataset.csv',
+    lawkit.LawkitOptions(format='json', consistency_check=True)
+)
+print(f"Validation status: {validation.data}")
+
+# Conflict diagnosis
+diagnosis = lawkit.diagnose_laws(
+    'complex_dataset.csv',
+    lawkit.LawkitOptions(format='json', report='detailed')
+)
+print(f"Diagnosis: {diagnosis.data}")
 ```
 
 ### Generate Sample Data
@@ -205,7 +217,7 @@ csv_data = """amount
 result = lawkit.analyze_string(
     csv_data,
     'benf',
-    lawkit.LawkitOptions(format='csv', output='json')
+    lawkit.LawkitOptions(format='json')
 )
 print(f"Risk assessment: {result.risk_level}")
 
@@ -214,7 +226,7 @@ json_data = '{"values": [12, 23, 34, 45, 56, 67, 78, 89]}'
 result = lawkit.analyze_string(
     json_data,
     'normal',
-    lawkit.LawkitOptions(format='json', output='json')
+    lawkit.LawkitOptions(format='json')
 )
 print(f"Is normal: {result.p_value > 0.05}")
 ```
@@ -399,7 +411,10 @@ print(f"Power law exponent: {result.exponent:.3f}")
 - `analyze_zipf(input_data, options)` - Zipf Law analysis
 - `analyze_normal(input_data, options)` - Normal distribution analysis
 - `analyze_poisson(input_data, options)` - Poisson distribution analysis
-- `compare_laws(input_data, options)` - Multi-law comparison
+- `analyze_laws(input_data, options)` - Multi-law analysis
+- `validate_laws(input_data, options)` - Data validation and consistency check
+- `diagnose_laws(input_data, options)` - Conflict diagnosis and detailed reporting
+- `compare_laws(input_data, options)` - Alias for analyze_laws (backward compatibility)
 - `generate_data(law_type, samples, **kwargs)` - Generate sample data
 - `analyze_string(content, law_type, options)` - Analyze string data directly
 

{lawkit_python-2.1.1 → lawkit_python-2.3.0}/README.md

@@ -22,7 +22,7 @@ print(result)
 # Get structured JSON output
 json_result = lawkit.analyze_benford(
     'accounting.csv',
-    lawkit.LawkitOptions(format='csv', output='json')
+    lawkit.LawkitOptions(format='json')
 )
 print(f"Risk level: {json_result.risk_level}")
 print(f"P-value: {json_result.p_value}")
@@ -30,7 +30,7 @@ print(f"P-value: {json_result.p_value}")
 # Check if data follows Pareto principle (80/20 rule)
 pareto_result = lawkit.analyze_pareto(
     'sales_data.csv',
-    lawkit.LawkitOptions(output='json', gini_coefficient=True)
+    lawkit.LawkitOptions(format='json', gini_coefficient=True)
 )
 print(f"Gini coefficient: {pareto_result.gini_coefficient}")
 print(f"80/20 concentration: {pareto_result.concentration_80_20}")
@@ -119,13 +119,27 @@ if normal_result.p_value < 0.05:
     if normal_result.outliers:
         print(f"Found {len(normal_result.outliers)} outliers")
 
-# Multi-law comparison
-comparison = lawkit.compare_laws(
+# Multi-law analysis
+analysis = lawkit.analyze_laws(
     'complex_dataset.csv',
-    lawkit.LawkitOptions(output='json')
+    lawkit.LawkitOptions(format='json', laws='benf,pareto,zipf')
 )
-print(f"Best fitting law: {comparison.data.get('best_law')}")
-print(f"Overall risk level: {comparison.risk_level}")
+print(f"Analysis results: {analysis.data}")
+print(f"Overall risk level: {analysis.risk_level}")
+
+# Data validation
+validation = lawkit.validate_laws(
+    'complex_dataset.csv',
+    lawkit.LawkitOptions(format='json', consistency_check=True)
+)
+print(f"Validation status: {validation.data}")
+
+# Conflict diagnosis
+diagnosis = lawkit.diagnose_laws(
+    'complex_dataset.csv',
+    lawkit.LawkitOptions(format='json', report='detailed')
+)
+print(f"Diagnosis: {diagnosis.data}")
 ```
 
 ### Generate Sample Data
@@ -165,7 +179,7 @@ csv_data = """amount
 result = lawkit.analyze_string(
     csv_data,
     'benf',
-    lawkit.LawkitOptions(format='csv', output='json')
+    lawkit.LawkitOptions(format='json')
 )
 print(f"Risk assessment: {result.risk_level}")
 
@@ -174,7 +188,7 @@ json_data = '{"values": [12, 23, 34, 45, 56, 67, 78, 89]}'
 result = lawkit.analyze_string(
     json_data,
     'normal',
-    lawkit.LawkitOptions(format='json', output='json')
+    lawkit.LawkitOptions(format='json')
 )
 print(f"Is normal: {result.p_value > 0.05}")
 ```
@@ -359,7 +373,10 @@ print(f"Power law exponent: {result.exponent:.3f}")
 - `analyze_zipf(input_data, options)` - Zipf Law analysis
 - `analyze_normal(input_data, options)` - Normal distribution analysis
 - `analyze_poisson(input_data, options)` - Poisson distribution analysis
-- `compare_laws(input_data, options)` - Multi-law comparison
+- `analyze_laws(input_data, options)` - Multi-law analysis
+- `validate_laws(input_data, options)` - Data validation and consistency check
+- `diagnose_laws(input_data, options)` - Conflict diagnosis and detailed reporting
+- `compare_laws(input_data, options)` - Alias for analyze_laws (backward compatibility)
 - `generate_data(law_type, samples, **kwargs)` - Generate sample data
 - `analyze_string(content, law_type, options)` - Analyze string data directly
 

{lawkit_python-2.1.1 → lawkit_python-2.3.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "lawkit-python"
-version = "2.1.1"
+version = "2.3.0"
 description = "Python wrapper for lawkit - Statistical law analysis toolkit for fraud detection and data quality assessment"
 readme = "README.md"
 license = "MIT"
 authors = [
-    { name = "kako-jun", email = "kako.jun.42@gmail.com" }
+    { name = "kako-jun" }
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -59,12 +59,10 @@ Documentation = "https://github.com/kako-jun/lawkit/tree/main/docs"
 dev = [
     "pytest >= 6.0",
     "pytest-cov",
-    "pytest-asyncio",
     "black",
     "isort",
     "mypy",
-    "ruff",
-    "types-requests"
+    "ruff"
 ]
 
 [project.scripts]
@@ -76,6 +74,7 @@ packages = ["src/lawkit"]
 [tool.hatch.build.targets.sdist]
 include = [
     "/src",
+    "/scripts",
     "/README.md"
 ]
 

{lawkit_python-2.1.1 → lawkit_python-2.3.0}/src/lawkit/__init__.py

@@ -13,6 +13,9 @@ from .lawkit import (
     analyze_zipf,
     analyze_normal,
     analyze_poisson,
+    analyze_laws,
+    validate_laws,
+    diagnose_laws,
     compare_laws,
     generate_data,
     analyze_string,
@@ -27,10 +30,8 @@ from .lawkit import (
     LawType,
 )
 
-# For backward compatibility and convenience
-from .compat import run_lawkit
 
-__version__ = "2.1.0"
+__version__ = "2.3.0"
 __all__ = [
     # Main analysis functions
     "analyze_benford",
@@ -38,6 +39,9 @@ __all__ = [
     "analyze_zipf",
     "analyze_normal",
     "analyze_poisson",
+    "analyze_laws",
+    "validate_laws",
+    "diagnose_laws",
     "compare_laws",
     
     # Utility functions
@@ -55,6 +59,4 @@ __all__ = [
     "OutputFormat", 
     "LawType",
     
-    # Backward compatibility
-    "run_lawkit",
 ]

{lawkit_python-2.1.1 → lawkit_python-2.3.0}/src/lawkit/lawkit.py

@@ -22,20 +22,44 @@ LawType = Literal["benf", "pareto", "zipf", "normal", "poisson"]
 class LawkitOptions:
     """Options for lawkit operations"""
     format: Optional[Format] = None
-    output: Optional[OutputFormat] = None
-    min_count: Optional[int] = None
-    threshold: Optional[float] = None
-    confidence: Optional[float] = None
+    quiet: bool = False
     verbose: bool = False
+    filter: Optional[str] = None
+    min_count: Optional[int] = None
     optimize: bool = False
-    international: bool = False
+    
+    # Integration-specific options
+    laws: Optional[str] = None  # "benf,pareto,zipf,normal,poisson"
+    focus: Optional[str] = None  # "quality", "concentration", "distribution", "anomaly"
+    threshold: Optional[float] = None  # Conflict detection threshold
+    recommend: bool = False
+    report: Optional[str] = None  # "summary", "detailed", "conflicting"
+    consistency_check: bool = False
+    cross_validation: bool = False
+    confidence_level: Optional[float] = None
+    purpose: Optional[str] = None  # "quality", "fraud", "concentration", "anomaly", "distribution", "general"
+    
     # Law-specific options
     gini_coefficient: bool = False
     percentiles: Optional[str] = None
     business_analysis: bool = False
+    concentration: Optional[float] = None
+    
+    # Benford-specific options
+    threshold_level: Optional[str] = None  # "low", "medium", "high", "critical", "auto"
+    
+    # Generate-specific options
+    samples: Optional[int] = None
+    seed: Optional[int] = None
+    output_file: Optional[str] = None
+    fraud_rate: Optional[float] = None
+    range: Optional[str] = None  # "1,100000"
+    scale: Optional[float] = None
+    
     # Statistical options
     test_type: Optional[str] = None
     alpha: Optional[float] = None
+    
     # Advanced options
     outlier_detection: bool = False
     time_series: bool = False
@@ -144,14 +168,17 @@ def _execute_lawkit(args: List[str]) -> tuple[str, str]:
             [lawkit_path] + args,
             capture_output=True,
             text=True,
-            check=True
+            check=False  # Don't raise exception on non-zero exit
         )
-        return result.stdout, result.stderr
-    except subprocess.CalledProcessError as e:
+        
+        # Exit codes 10-19 are typically warnings, not fatal errors
+        if result.returncode == 0 or (result.returncode >= 10 and result.returncode <= 19):
+            return result.stdout, result.stderr
+        
         raise LawkitError(
-            f"lawkit exited with code {e.returncode}",
-            e.returncode,
-            e.stderr or ""
+            f"lawkit exited with code {result.returncode}",
+            result.returncode,
+            result.stderr or ""
         )
     except FileNotFoundError:
         raise LawkitError(
@@ -192,10 +219,14 @@ def analyze_benford(
     # Add common options
     _add_common_options(args, options)
     
+    # Add Benford-specific options
+    if options.threshold_level:
+        args.extend(["--threshold", options.threshold_level])
+    
     stdout, stderr = _execute_lawkit(args)
     
     # If output format is JSON, parse the result
-    if options.output == "json":
+    if options.format == "json":
         try:
             json_data = json.loads(stdout)
             return LawkitResult(json_data, "benford")
@@ -238,6 +269,9 @@ def analyze_pareto(
     _add_common_options(args, options)
     
     # Add Pareto-specific options
+    if options.concentration is not None:
+        args.extend(["--concentration", str(options.concentration)])
+    
     if options.gini_coefficient:
         args.append("--gini-coefficient")
     
@@ -250,7 +284,7 @@ def analyze_pareto(
     stdout, stderr = _execute_lawkit(args)
     
     # If output format is JSON, parse the result
-    if options.output == "json":
+    if options.format == "json":
         try:
             json_data = json.loads(stdout)
             return LawkitResult(json_data, "pareto")
@@ -294,7 +328,7 @@ def analyze_zipf(
     stdout, stderr = _execute_lawkit(args)
     
     # If output format is JSON, parse the result
-    if options.output == "json":
+    if options.format == "json":
         try:
             json_data = json.loads(stdout)
             return LawkitResult(json_data, "zipf")
@@ -347,7 +381,7 @@ def analyze_normal(
     stdout, stderr = _execute_lawkit(args)
     
     # If output format is JSON, parse the result
-    if options.output == "json":
+    if options.format == "json":
         try:
             json_data = json.loads(stdout)
             return LawkitResult(json_data, "normal")
@@ -391,7 +425,7 @@ def analyze_poisson(
     stdout, stderr = _execute_lawkit(args)
     
     # If output format is JSON, parse the result
-    if options.output == "json":
+    if options.format == "json":
         try:
             json_data = json.loads(stdout)
             return LawkitResult(json_data, "poisson")
@@ -402,12 +436,12 @@ def analyze_poisson(
     return stdout
 
 
-def compare_laws(
+def analyze_laws(
     input_data: str,
     options: Optional[LawkitOptions] = None
 ) -> Union[str, LawkitResult]:
     """
-    Compare multiple statistical laws on the same data
+    Analyze data using multiple statistical laws (basic analysis)
     
     Args:
         input_data: Path to input file or '-' for stdin
@@ -417,17 +451,105 @@ def compare_laws(
         String output for text format, or LawkitResult for JSON format
         
     Examples:
-        >>> result = compare_laws('dataset.csv')
+        >>> result = analyze_laws('dataset.csv')
         >>> print(result)
         
-        >>> json_result = compare_laws('complex_data.json', 
-        ...                          LawkitOptions(output='json'))
+        >>> json_result = analyze_laws('complex_data.json', 
+        ...                          LawkitOptions(format='json'))
         >>> print(f"Risk level: {json_result.risk_level}")
     """
     if options is None:
         options = LawkitOptions()
     
-    args = ["compare", input_data]
+    args = ["analyze", input_data]
+    
+    # Add common options
+    _add_common_options(args, options)
+    
+    stdout, stderr = _execute_lawkit(args)
+    
+    # If output format is JSON, parse the result
+    if options.format == "json":
+        try:
+            json_data = json.loads(stdout)
+            return LawkitResult(json_data, "analyze")
+        except json.JSONDecodeError as e:
+            raise LawkitError(f"Failed to parse JSON output: {e}", -1, "")
+    
+    # Return raw output for other formats
+    return stdout
+
+
+def validate_laws(
+    input_data: str,
+    options: Optional[LawkitOptions] = None
+) -> Union[str, LawkitResult]:
+    """
+    Validate data consistency using multiple statistical laws
+    
+    Args:
+        input_data: Path to input file or '-' for stdin
+        options: Analysis options
+        
+    Returns:
+        String output for text format, or LawkitResult for JSON format
+        
+    Examples:
+        >>> result = validate_laws('dataset.csv')
+        >>> print(result)
+        
+        >>> json_result = validate_laws('complex_data.json', 
+        ...                           LawkitOptions(format='json'))
+        >>> print(f"Validation result: {json_result.data}")
+    """
+    if options is None:
+        options = LawkitOptions()
+    
+    args = ["validate", input_data]
+    
+    # Add common options
+    _add_common_options(args, options)
+    
+    stdout, stderr = _execute_lawkit(args)
+    
+    # If output format is JSON, parse the result
+    if options.format == "json":
+        try:
+            json_data = json.loads(stdout)
+            return LawkitResult(json_data, "validate")
+        except json.JSONDecodeError as e:
+            raise LawkitError(f"Failed to parse JSON output: {e}", -1, "")
+    
+    # Return raw output for other formats
+    return stdout
+
+
+def diagnose_laws(
+    input_data: str,
+    options: Optional[LawkitOptions] = None
+) -> Union[str, LawkitResult]:
+    """
+    Diagnose conflicts and generate detailed analysis report
+    
+    Args:
+        input_data: Path to input file or '-' for stdin
+        options: Analysis options
+        
+    Returns:
+        String output for text format, or LawkitResult for JSON format
+        
+    Examples:
+        >>> result = diagnose_laws('dataset.csv')
+        >>> print(result)
+        
+        >>> json_result = diagnose_laws('complex_data.json', 
+        ...                           LawkitOptions(format='json'))
+        >>> print(f"Diagnosis: {json_result.data}")
+    """
+    if options is None:
+        options = LawkitOptions()
+    
+    args = ["diagnose", input_data]
     
     # Add common options
     _add_common_options(args, options)
@@ -435,10 +557,10 @@ def compare_laws(
     stdout, stderr = _execute_lawkit(args)
     
     # If output format is JSON, parse the result
-    if options.output == "json":
+    if options.format == "json":
         try:
             json_data = json.loads(stdout)
-            return LawkitResult(json_data, "compare")
+            return LawkitResult(json_data, "diagnose")
         except json.JSONDecodeError as e:
             raise LawkitError(f"Failed to parse JSON output: {e}", -1, "")
     
@@ -446,10 +568,13 @@ def compare_laws(
     return stdout
 
 
+# Backward compatibility alias
+compare_laws = analyze_laws
+
+
 def generate_data(
     law_type: LawType,
-    samples: int = 1000,
-    seed: Optional[int] = None,
+    options: Optional[LawkitOptions] = None,
     **kwargs
 ) -> str:
     """
@@ -457,26 +582,46 @@ def generate_data(
     
     Args:
         law_type: Type of statistical law to use
-        samples: Number of samples to generate
-        seed: Random seed for reproducibility
-        **kwargs: Law-specific parameters
+        options: Generation options (samples, seed, etc.)
+        **kwargs: Law-specific parameters (deprecated, use options instead)
         
     Returns:
         Generated data as string
         
     Examples:
-        >>> data = generate_data('benf', samples=1000, seed=42)
+        >>> data = generate_data('benf', LawkitOptions(samples=1000, seed=42))
         >>> print(data)
         
-        >>> normal_data = generate_data('normal', samples=500, mean=100, stddev=15)
-        >>> pareto_data = generate_data('pareto', samples=1000, concentration=0.8)
+        >>> options = LawkitOptions(samples=500, fraud_rate=0.1, range="1,10000")
+        >>> normal_data = generate_data('normal', options)
+        >>> pareto_data = generate_data('pareto', LawkitOptions(concentration=0.8))
     """
-    args = ["generate", law_type, "--samples", str(samples)]
+    if options is None:
+        options = LawkitOptions()
     
-    if seed is not None:
-        args.extend(["--seed", str(seed)])
+    args = ["generate", law_type]
     
-    # Add law-specific parameters
+    # Add common options
+    _add_common_options(args, options)
+    
+    # Add generate-specific options
+    if options.samples is not None:
+        args.extend(["--samples", str(options.samples)])
+    
+    if options.seed is not None:
+        args.extend(["--seed", str(options.seed)])
+    
+    if options.output_file:
+        args.extend(["--output-file", options.output_file])
+    
+    if options.fraud_rate is not None:
+        args.extend(["--fraud-rate", str(options.fraud_rate)])
+    
+    # Note: --range option not available in current CLI
+    
+    # Note: --scale option may not be available for all law types
+    
+    # Add law-specific parameters (backward compatibility)
     for key, value in kwargs.items():
         key_formatted = key.replace("_", "-")
         args.extend([f"--{key_formatted}", str(value)])
@@ -539,29 +684,52 @@ def _add_common_options(args: List[str], options: LawkitOptions) -> None:
     if options.format:
         args.extend(["--format", options.format])
     
-    if options.output:
-        args.extend(["--output", options.output])
+    if options.quiet:
+        args.append("--quiet")
+    
+    if options.verbose:
+        args.append("--verbose")
+    
+    if options.filter:
+        args.extend(["--filter", options.filter])
     
     if options.min_count is not None:
         args.extend(["--min-count", str(options.min_count)])
     
+    if options.optimize:
+        args.append("--optimize")
+    
+    # Integration-specific options
+    if options.laws:
+        args.extend(["--laws", options.laws])
+    
+    if options.focus:
+        args.extend(["--focus", options.focus])
+    
     if options.threshold is not None:
         args.extend(["--threshold", str(options.threshold)])
     
-    if options.confidence is not None:
-        args.extend(["--confidence", str(options.confidence)])
+    if options.recommend:
+        args.append("--recommend")
     
-    if options.alpha is not None:
-        args.extend(["--alpha", str(options.alpha)])
+    if options.report:
+        args.extend(["--report", options.report])
     
-    if options.verbose:
-        args.append("--verbose")
+    if options.consistency_check:
+        args.append("--consistency-check")
     
-    if options.optimize:
-        args.append("--optimize")
+    if options.cross_validation:
+        args.append("--cross-validation")
+    
+    if options.confidence_level is not None:
+        args.extend(["--confidence-level", str(options.confidence_level)])
+    
+    if options.purpose:
+        args.extend(["--purpose", options.purpose])
     
-    if options.international:
-        args.append("--international")
+    # Advanced options
+    if options.alpha is not None:
+        args.extend(["--alpha", str(options.alpha)])
     
     if options.time_series:
         args.append("--time-series")

lawkit_python-2.1.1/src/lawkit/compat.py

@@ -1,204 +0,0 @@
-"""
-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