auto-code-fixer 0.2.5__tar.gz → 0.2.6__tar.gz

{auto_code_fixer-0.2.5 → auto_code_fixer-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-code-fixer
-Version: 0.2.5
+Version: 0.2.6
 Summary: Automatically fix Python code using ChatGPT
 Author-email: Arif Shah <ashah7775@gmail.com>
 License: MIT

auto_code_fixer-0.2.6/auto_code_fixer/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.6"

{auto_code_fixer-0.2.5 → auto_code_fixer-0.2.6}/auto_code_fixer/cli.py

@@ -2,7 +2,6 @@ import argparse
 import shutil
 import tempfile
 import time
-import os
 from decouple import config
 
 from auto_code_fixer.runner import run_code
@@ -14,7 +13,6 @@ from auto_code_fixer.utils import (
     log,
     set_verbose,
 )
-from auto_code_fixer.guard import import_hijacked
 from auto_code_fixer import __version__
 
 MAX_RETRIES = 5
@@ -24,22 +22,16 @@ def fix_file(file_path, project_root, api_key, ask, verbose):
     log(f"Processing file: {file_path}")
 
     with open(file_path) as f:
-        current_code = f.read()   # 🔑 SOURCE OF TRUTH
+        original_code = f.read()
 
     temp_dir = tempfile.mkdtemp(prefix="codefix_")
-    temp_file = os.path.join(temp_dir, "temp.py")
-
-    # write initial code to temp
-    with open(temp_file, "w") as f:
-        f.write(current_code)
+    temp_file = f"{temp_dir}/temp.py"
+    shutil.copy(file_path, temp_file)
 
     for attempt in range(MAX_RETRIES):
         log(f"Run attempt #{attempt + 1}")
 
-        retcode, stdout, stderr = run_code(
-            temp_file,
-            project_root=project_root,
-        )
+        retcode, stdout, stderr = run_code(temp_file)
 
         if verbose:
             if stdout:
@@ -55,15 +47,13 @@ def fix_file(file_path, project_root, api_key, ask, verbose):
                     confirm = input(
                         f"Overwrite original file '{file_path}' with fixed version? (y/n): "
                     ).strip().lower()
+
                     if confirm != "y":
                         log("User declined overwrite", "WARN")
                         shutil.rmtree(temp_dir)
                         return
 
-                # ✅ WRITE FROM MEMORY, NOT TEMP FILE
-                with open(file_path, "w") as f:
-                    f.write(current_code)
-
+                shutil.copy(temp_file, file_path)
                 log(f"File updated: {file_path}")
 
             shutil.rmtree(temp_dir)
@@ -73,55 +63,24 @@ def fix_file(file_path, project_root, api_key, ask, verbose):
         log("Error detected ❌", "ERROR")
         print(stderr)
 
-        if check_and_install_missing_lib(stderr, project_root):
+        if check_and_install_missing_lib(stderr):
             log("Missing dependency installed, retrying…")
             time.sleep(1)
             continue
 
         log("Sending code & error to GPT 🧠", "DEBUG")
-
         fixed_code = fix_code_with_gpt(
-            current_code,
+            open(temp_file).read(),
             stderr,
             api_key,
         )
 
-        if import_hijacked(current_code, fixed_code):
-            log(
-                "GPT attempted to hijack local imports. Rejecting fix.",
-                "ERROR",
-            )
-            break
-
-        if fixed_code.strip() == current_code.strip():
+        if fixed_code.strip() == open(temp_file).read().strip():
             log("GPT returned no changes. Stopping.", "WARN")
             break
 
-        import ast
-
-        # Validate GPT output BEFORE accepting it
-        try:
-            ast.parse(fixed_code)
-        except SyntaxError:
-            log(
-                "GPT returned invalid or empty Python code. Rejecting fix.",
-                "ERROR",
-            )
-            break
-
-        if not fixed_code.strip():
-            log(
-                "GPT returned empty code. Rejecting fix.",
-                "ERROR",
-            )
-            break
-
-        # ✅ SAFE: update memory only after validation
-        current_code = fixed_code
-
-        # then update temp file for next execution
         with open(temp_file, "w") as f:
-            f.write(current_code)
+            f.write(fixed_code)
 
         log("Code updated by GPT ✏️")
         time.sleep(1)
@@ -130,7 +89,6 @@ def fix_file(file_path, project_root, api_key, ask, verbose):
     shutil.rmtree(temp_dir)
 
 
-
 def main():
     parser = argparse.ArgumentParser(
         description="Auto-fix Python code using ChatGPT"
@@ -151,23 +109,35 @@ def main():
     parser.add_argument("--project-root", default=".")
     parser.add_argument("--api-key")
 
+    # ✅ Proper boolean flags
     ask_group = parser.add_mutually_exclusive_group()
-    ask_group.add_argument("--ask", action="store_true")
-    ask_group.add_argument("--no-ask", action="store_true")
+    ask_group.add_argument(
+        "--ask",
+        action="store_true",
+        help="Ask before overwriting files",
+    )
+    ask_group.add_argument(
+        "--no-ask",
+        action="store_true",
+        help="Do not ask before overwriting files",
+    )
 
-    parser.add_argument("--verbose", action="store_true")
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable verbose/debug output",
+    )
 
     args = parser.parse_args()
 
     if not args.entry_file:
         parser.error("the following arguments are required: entry_file")
 
-    # 🔑 NORMALIZE ROOT PATH ONCE
-    project_root = os.path.abspath(args.project_root)
-
+    # ENV defaults
     env_ask = config("AUTO_CODE_FIXER_ASK", default=False, cast=bool)
     env_verbose = config("AUTO_CODE_FIXER_VERBOSE", default=False, cast=bool)
 
+    # Final ask resolution (CLI overrides ENV)
     if args.ask:
         ask = True
     elif args.no_ask:
@@ -180,4 +150,4 @@ def main():
 
     files = discover_all_files(args.entry_file)
     for file in files:
-        fix_file(file, project_root, args.api_key, ask, verbose)
+        fix_file(file, args.project_root, args.api_key, ask, verbose)

auto_code_fixer-0.2.6/auto_code_fixer/fixer.py

@@ -0,0 +1,55 @@
+import os
+import time
+from decouple import config
+from openai import OpenAI
+
+
+def get_openai_client(api_key=None):
+    key = (
+            api_key
+            or os.getenv("OPENAI_API_KEY")
+            or config("OPENAI_API_KEY", default=None)
+    )
+
+    if not key:
+        raise RuntimeError(
+            "OpenAI API key not found. "
+            "Set OPENAI_API_KEY env var or .env file or pass --api-key"
+        )
+
+    return OpenAI(api_key=key)
+
+
+def fix_code_with_gpt(original_code, error_log, api_key=None):
+    client = get_openai_client(api_key)
+
+    prompt = f"""
+You are a senior Python engineer.
+Fix the following Python code so it runs without errors.
+
+Code:
+{original_code}
+
+Error:
+{error_log}
+
+Return ONLY the full corrected Python code.
+"""
+
+    response = client.chat.completions.create(
+        model="gpt-5",
+        messages=[
+            {"role": "system", "content": "You fix broken Python code."},
+            {"role": "user", "content": prompt},
+        ],
+        max_completion_tokens=1500,
+    )
+
+    fixed_code = response.choices[0].message.content.strip()
+
+    if fixed_code.startswith("```"):
+        fixed_code = "\n".join(fixed_code.split("\n")[1:])
+    if fixed_code.endswith("```"):
+        fixed_code = "\n".join(fixed_code.split("\n")[:-1])
+
+    return fixed_code.strip()

auto_code_fixer-0.2.6/auto_code_fixer/installer.py

@@ -0,0 +1,16 @@
+import re
+import subprocess
+import sys
+
+
+def check_and_install_missing_lib(stderr):
+    match = re.search(r"No module named '([^']+)'", stderr)
+    if not match:
+        return False
+
+    lib = match.group(1)
+    try:
+        subprocess.check_call([sys.executable, "-m", "pip", "install", lib])
+        return True
+    except subprocess.CalledProcessError:
+        return False

auto_code_fixer-0.2.6/auto_code_fixer/runner.py

@@ -0,0 +1,14 @@
+import subprocess
+
+
+def run_code(path_to_code):
+    try:
+        result = subprocess.run(
+            ["python3", path_to_code],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        return result.returncode, result.stdout, result.stderr
+    except subprocess.TimeoutExpired:
+        return -1, "", "TimeoutExpired: Code took too long to run."

{auto_code_fixer-0.2.5 → auto_code_fixer-0.2.6}/auto_code_fixer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: auto-code-fixer
-Version: 0.2.5
+Version: 0.2.6
 Summary: Automatically fix Python code using ChatGPT
 Author-email: Arif Shah <ashah7775@gmail.com>
 License: MIT

{auto_code_fixer-0.2.5 → auto_code_fixer-0.2.6}/auto_code_fixer.egg-info/SOURCES.txt

@@ -4,7 +4,6 @@ pyproject.toml
 auto_code_fixer/__init__.py
 auto_code_fixer/cli.py
 auto_code_fixer/fixer.py
-auto_code_fixer/guard.py
 auto_code_fixer/installer.py
 auto_code_fixer/runner.py
 auto_code_fixer/utils.py

{auto_code_fixer-0.2.5 → auto_code_fixer-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "auto-code-fixer"
-version = "0.2.5"
+version = "0.2.6"
 description = "Automatically fix Python code using ChatGPT"
 readme = "README.md"
 

auto_code_fixer-0.2.5/auto_code_fixer/__init__.py

@@ -1,2 +0,0 @@
-__version__ = "0.2.5"
-

auto_code_fixer-0.2.5/auto_code_fixer/fixer.py

@@ -1,60 +0,0 @@
-from openai import OpenAI
-from decouple import config
-
-client = OpenAI(api_key=config("chat_gpt_secret_key"))
-
-
-def fix_code_with_gpt(original_code: str, error_log: str, api_key: str | None):
-    """
-    Send code + error to GPT and return fixed code.
-    Enforces strict rules to prevent semantic-breaking fixes.
-    """
-
-    system_prompt = """
-You are a senior Python engineer fixing code.
-
-STRICT RULES (DO NOT VIOLATE):
-- NEVER replace or wrap local imports with try/except.
-- NEVER inline, duplicate, or redefine code from other local files.
-- NEVER change import statements for local modules.
-- Assume all local imports are valid and must remain unchanged.
-- If an import fails, assume environment configuration is incorrect.
-- Only fix syntax errors or runtime errors in the current file.
-- Return ONLY valid Python code. No markdown. No explanation.
-"""
-
-    user_prompt = f"""
-The following Python code has an error.
-
-CODE:
-{original_code}
-
-ERROR:
-{error_log}
-
-Fix the code according to the rules.
-"""
-
-    try:
-        response = client.chat.completions.create(
-            model="gpt-5",
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_prompt},
-            ],
-            max_completion_tokens=1500,
-        )
-
-        fixed_code = response.choices[0].message.content.strip()
-
-        # strip accidental markdown fences
-        if fixed_code.startswith("```"):
-            fixed_code = "\n".join(fixed_code.splitlines()[1:])
-        if fixed_code.endswith("```"):
-            fixed_code = "\n".join(fixed_code.splitlines()[:-1])
-
-        return fixed_code.strip()
-
-    except Exception as e:
-        print(f"Error calling OpenAI API: {e}")
-        return original_code

auto_code_fixer-0.2.5/auto_code_fixer/guard.py

@@ -1,19 +0,0 @@
-def import_hijacked(original_code: str, fixed_code: str) -> bool:
-    """
-    Detects GPT cheating by replacing imports with try/except fallbacks
-    or inlining local module logic.
-    """
-
-    if "from " not in original_code:
-        return False
-
-    # common cheating patterns
-    bad_patterns = [
-        "try:",
-        "except ImportError",
-        "except ModuleNotFoundError",
-        "def greet(",
-        "def add(",
-    ]
-
-    return any(p in fixed_code for p in bad_patterns)

auto_code_fixer-0.2.5/auto_code_fixer/installer.py

@@ -1,25 +0,0 @@
-import os
-import re
-import sys
-import subprocess
-
-
-def check_and_install_missing_lib(stderr, project_root):
-    match = re.search(r"No module named '([^']+)'", stderr)
-    if not match:
-        return False
-
-    missing = match.group(1)
-
-    # 🔒 CRITICAL: skip local project modules
-    local_file = os.path.join(project_root, f"{missing}.py")
-    if os.path.exists(local_file):
-        return False
-
-    try:
-        subprocess.check_call(
-            [sys.executable, "-m", "pip", "install", missing]
-        )
-        return True
-    except subprocess.CalledProcessError:
-        return False

auto_code_fixer-0.2.5/auto_code_fixer/runner.py

@@ -1,30 +0,0 @@
-import subprocess
-import os
-import sys
-
-
-def run_code(script_path, project_root):
-    env = os.environ.copy()
-
-    script_dir = os.path.dirname(script_path)
-
-    # 🔑 CRITICAL: include BOTH project root and script dir
-    paths = [project_root, script_dir]
-
-    existing = env.get("PYTHONPATH", "")
-    if existing:
-        paths.append(existing)
-
-    env["PYTHONPATH"] = os.pathsep.join(paths)
-
-    try:
-        result = subprocess.run(
-            [sys.executable, script_path],
-            capture_output=True,
-            text=True,
-            timeout=15,
-            env=env,
-        )
-        return result.returncode, result.stdout, result.stderr
-    except subprocess.TimeoutExpired:
-        return -1, "", "TimeoutExpired: Code took too long to run."