error-translator-cli-v2 0.1.2__tar.gz → 1.0.0__tar.gz

{error_translator_cli_v2-0.1.2 → error_translator_cli_v2-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: error-translator-cli-v2
-Version: 0.1.2
+Version: 1.0.0
 Summary: A CLI tool that explains Python errors in simple human language.
 Author-email: Gourabananda Datta <gourabanandadatta@zohomail.com>
 Requires-Python: >=3.7

error_translator_cli_v2-1.0.0/error_translator/auto.py

@@ -0,0 +1,22 @@
+import sys
+import traceback
+from .core import translate_error
+from .cli import print_result
+
+def magic_hook(exc_type, exc_value, tb):
+    """
+    This function intercepts a Python crash right before it prints 
+    to the terminal, formats the error, and translates it.
+    """
+    # 1. Convert the raw crash data into a standard traceback string
+    tb_lines = traceback.format_exception(exc_type, exc_value, tb)
+    tb_string = "".join(tb_lines)
+    
+    # 2. Pass it through our translation engine
+    result = translate_error(tb_string)
+    
+    # 3. Print our beautiful colorized output instead of the ugly default
+    print_result(result)
+
+# The Magic Trick: Replace Python's default crash handler with ours
+sys.excepthook = magic_hook

error_translator_cli_v2-1.0.0/error_translator/cli.py

@@ -0,0 +1,93 @@
+import sys
+import argparse
+from .core import translate_error
+
+# ANSI Color Codes
+class Colors:
+    RED = '\033[91m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    CYAN = '\033[96m'
+    BOLD = '\033[1m'
+    RESET = '\033[0m'
+
+def print_result(result: dict):
+    """Prints the translated error to the terminal with colors."""
+    print(f"\n{Colors.RED}{Colors.BOLD} Error Detected:{Colors.RESET}")
+    print(f"{result.get('matched_error', 'N/A')}")
+    
+    if "file" in result:
+        print(f"{Colors.YELLOW} Location: {result['file']} (Line {result['line']}){Colors.RESET}\n")
+    else:
+        print()
+    
+    print(f"{Colors.CYAN}{Colors.BOLD} Explanation:{Colors.RESET}")
+    print(f"{result['explanation']}\n")
+    
+    print(f"{Colors.GREEN}{Colors.BOLD} Suggested Fix:{Colors.RESET}")
+    print(f"{result['fix']}\n")
+
+def run_script(script_name: str):
+    """Runs a python script in the background and catches its errors."""
+    import subprocess
+    try:
+        # Run the script using the current Python environment
+        result = subprocess.run(
+            [sys.executable, script_name],
+            capture_output=True,
+            text=True
+        )
+        
+        # If the script ran perfectly (Return Code 0), print standard output
+        if result.returncode == 0:
+            print(result.stdout, end="")
+        
+        # If the script crashed, print whatever succeeded, THEN translate the error
+        else:
+            if result.stdout:
+                print(result.stdout, end="")
+            
+            translation = translate_error(result.stderr)
+            print_result(translation)
+            
+    except FileNotFoundError:
+        print(f"{Colors.RED}Error: Could not find script '{script_name}'{Colors.RESET}")
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Translate Python error messages into simple English."
+    )
+    
+    # Allow multiple arguments so we can accept "run script.py" or a long error string
+    parser.add_argument(
+        "args", 
+        nargs="*", 
+        help="Use 'run <script.py>' to execute a file, or pass an error string."
+    )
+
+    parsed_args = parser.parse_args()
+
+    # 1. Handle Piped Input (e.g., cat error.log | explain-error)
+    if not sys.stdin.isatty():
+        error_input = sys.stdin.read()
+        if error_input.strip():
+            print_result(translate_error(error_input))
+            return
+
+    # 2. Print help if no arguments
+    if not parsed_args.args:
+        parser.print_help()
+        sys.exit(1)
+
+    # 3. Check if the user used the "run" command
+    if parsed_args.args[0] == "run" and len(parsed_args.args) > 1:
+        script_name = parsed_args.args[1]
+        run_script(script_name)
+    
+    # 4. Fallback: Treat the input as a raw error string
+    else:
+        error_input = " ".join(parsed_args.args)
+        print_result(translate_error(error_input))
+
+if __name__ == "__main__":
+    main()

error_translator_cli_v2-1.0.0/error_translator/core.py

@@ -0,0 +1,53 @@
+import json
+import os
+
+def load_rules():
+    """Loads the error rules from the JSON file."""
+    # Find the absolute path to the json file next to this script
+    # current_dir = os.path.dirname(data\rules.json)
+    current_dir = 'data/'
+    json_path = os.path.join(current_dir, 'rules.json')
+    
+    with open(json_path, 'r') as file:
+        return json.load(file)
+
+def translate_error(traceback_text: str) -> dict:
+    import re # Lazy import
+    
+    data = load_rules()
+    rules = data["rules"]
+    default_error = data["default"]
+
+    lines = [line.strip() for line in traceback_text.strip().split('\n') if line.strip()]
+    if not lines:
+        return {"explanation": "No error text provided.", "fix": "Provide a valid Python error."}
+    
+    actual_error_line = lines[-1]
+
+    # Flexible regex to catch single or double quotes, and handle missing ones
+    location_match = re.search(r'File\s+[\'"]?(.*?)[\'"]?,\s+line\s+(\d+)', traceback_text)
+    file_name = location_match.group(1) if location_match else "Unknown File"
+    line_number = location_match.group(2) if location_match else "Unknown Line"
+
+    for rule in rules:
+        # Compile the regex pattern on the fly
+        pattern = re.compile(rule["pattern"])
+        match = pattern.search(actual_error_line)
+        
+        if match:
+            extracted_values = match.groups()
+            return {
+                "explanation": rule["explanation"].format(*extracted_values),
+                "fix": rule["fix"].format(*extracted_values),
+                "matched_error": actual_error_line,
+                "file": file_name,
+                "line": line_number
+            }
+
+    return {
+        "explanation": default_error["explanation"],
+        "fix": default_error["fix"],
+        "matched_error": actual_error_line,
+        "file": file_name,
+        "line": line_number
+    }

{error_translator_cli_v2-0.1.2 → error_translator_cli_v2-1.0.0}/error_translator_cli_v2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: error-translator-cli-v2
-Version: 0.1.2
+Version: 1.0.0
 Summary: A CLI tool that explains Python errors in simple human language.
 Author-email: Gourabananda Datta <gourabanandadatta@zohomail.com>
 Requires-Python: >=3.7

{error_translator_cli_v2-0.1.2 → error_translator_cli_v2-1.0.0}/error_translator_cli_v2.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 error_translator/__init__.py
+error_translator/auto.py
 error_translator/cli.py
 error_translator/core.py
 error_translator/rules.py

{error_translator_cli_v2-0.1.2 → error_translator_cli_v2-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "error-translator-cli-v2"
-version = "0.1.2"
+version = "1.0.0"
 description = "A CLI tool that explains Python errors in simple human language."
 readme = "README.md"
 requires-python = ">=3.7"

error_translator_cli_v2-1.0.0/tests/test_core.py

@@ -0,0 +1,35 @@
+import error_translator.auto
+
+def test_name_error_translation_double_quotes():
+    """Test standard traceback with double quotes around the filename."""
+    mock_traceback = """Traceback (most recent call last):
+  File "script.py", line 2, in <module>
+    print(my_variable)
+NameError: name 'my_variable' is not defined"""
+
+    result = translate_error(mock_traceback)
+    
+    assert "my_variable" in result["explanation"]
+    assert result["file"] == "script.py"
+    assert result["line"] == "2"
+
+def test_name_error_translation_single_quotes():
+    """Test PowerShell-style traceback with single quotes."""
+    mock_traceback = """Traceback (most recent call last):
+  File 'script.py', line 2, in <module>
+    print(my_variable)
+NameError: name 'my_variable' is not defined"""
+
+    result = translate_error(mock_traceback)
+    
+    assert result["file"] == "script.py"
+    assert result["line"] == "2"
+
+def test_unknown_error_fallback():
+    """Test that garbage input returns the default safe message."""
+    mock_traceback = "Something completely random went wrong here."
+    
+    result = translate_error(mock_traceback)
+    
+    assert "unknown error" in result["explanation"]
+    assert result["matched_error"] == "Something completely random went wrong here."

error_translator_cli_v2-0.1.2/error_translator/cli.py

@@ -1,61 +0,0 @@
-import sys
-import argparse
-
-from cv2 import line
-from .core import translate_error
-
-# ANSI Color Codes for terminal formatting
-class Colors:
-    RED = '\033[91m'
-    GREEN = '\033[92m'
-    YELLOW = '\033[93m'
-    CYAN = '\033[96m'
-    BOLD = '\033[1m'
-    RESET = '\033[0m'
-
-def print_result(result: dict):
-    """Prints the translated error to the terminal with colors."""
-    print(f"\n{Colors.RED}{Colors.BOLD}🚨 Error Detected:{Colors.RESET}")
-    print(f"{result.get('matched_error', 'N/A')}\n")
-    
-    # If file and line info is available, print it
-    if "file" in result:
-        print(f"{Colors.YELLOW}📍 Location: {result['file']} (Line {result['line']}){Colors.RESET}\n")
-    else:
-        print() # Just a newline
-
-    print(f"{Colors.CYAN}{Colors.BOLD}🧠 Explanation:{Colors.RESET}")
-    print(f"{result['explanation']}\n")
-    
-    print(f"{Colors.GREEN}{Colors.BOLD}🛠️  Suggested Fix:{Colors.RESET}")
-    print(f"{result['fix']}\n")
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Translate Python error messages into simple English."
-    )
-    
-    parser.add_argument(
-        "error_text", 
-        nargs="?", 
-        help="The error message or traceback string to translate."
-    )
-
-    args = parser.parse_args()
-
-    # Read from positional argument OR standard input (piping)
-    error_input = args.error_text
-
-    if not error_input and not sys.stdin.isatty():
-        # Allows usage like: cat error.log | explain-error
-        error_input = sys.stdin.read()
-
-    if not error_input:
-        parser.print_help()
-        sys.exit(1)
-
-    result = translate_error(error_input)
-    print_result(result)
-
-if __name__ == "__main__":
-    main()

error_translator_cli_v2-0.1.2/error_translator/core.py

@@ -1,45 +0,0 @@
-from .rules import ERROR_RULES, DEFAULT_ERROR
-import re
-
-def translate_error(traceback_text: str) -> dict:
-    """
-    Parses traceback text and returns a human-readable explanation and fix.
-    """
-# Update this line inside your translate_error function:
-    location_match = re.search(r'File\s+[\'"]?(.*?)[\'"]?,\s+line\s+(\d+)', traceback_text)    
-    file_name = location_match.group(1) if location_match else "unknown file"
-    line_number = location_match.group(2) if location_match else "unknown line"
-    # Grab the last non-empty line of the traceback, which usually contains the actual error
-    print(f"\n--- DEBUG RAW INPUT ---\n{repr(traceback_text)}\n-----------------------\n")
-    lines = [line.strip() for line in traceback_text.strip().split('\n') if line.strip()]
-    if not lines:
-        return {"explanation": "No error text provided.", "fix": "Provide a valid Python error."}
-    
-    actual_error_line = lines[-1]
-
-    for rule in ERROR_RULES:
-        match = rule["pattern"].search(actual_error_line)
-        if match:
-            # Extract the captured regex groups (e.g., the variable name)
-            extracted_values = match.groups()
-            
-            # Format the explanation and fix using the extracted values
-            explanation = rule["explanation"].format(*extracted_values)
-            fix = rule["fix"].format(*extracted_values)
-            
-            return {
-                "explanation": explanation,
-                "fix": fix,
-                "matched_error": actual_error_line,
-                "file": file_name,
-                "line": line_number,
-            }
-
-    # If no rules match, return the default payload
-    return {
-        "explanation": DEFAULT_ERROR["explanation"],
-        "fix": DEFAULT_ERROR["fix"],
-        "matched_error": actual_error_line,
-        "file": file_name,
-        "line": line_number,
-    }

error_translator_cli_v2-0.1.2/tests/test_core.py

@@ -1,13 +0,0 @@
-from error_translator.core import translate_error
-
-def test_name_error_translation():
-    mock_traceback = """Traceback (most recent call last):
-  File "main.py", line 3, in <module>
-    print(x)
-NameError: name 'x' is not defined"""
-
-    result = translate_error(mock_traceback)
-    
-    assert "x" in result["explanation"]
-    assert result["file"] == "main.py"
-    assert result["line"] == "3"