pyfixer-ai 0.4.0__py3-none-any.whl

pyfixer/__init__.py

@@ -0,0 +1,4 @@
+"""PyFixer — upload a Python file, get bugs found, fixed, and explained.
+
+Your API key, your control: fixes are only applied after you approve them.
+"""

pyfixer/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pyfixer/_pair_probe.py

@@ -0,0 +1,114 @@
+import json
+import signal
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def _emit(kind, **kw):
+    row = {"kind": kind, **kw}
+    print(json.dumps(row))
+    sys.stdout.flush()
+
+
+src_mode = sys.argv[1]  # 'exec' | 'import'
+pre_path = sys.argv[2]
+post_path = sys.argv[3]
+calls_path = sys.argv[4]
+
+with Path(calls_path).open(encoding="utf-8") as calls_f:
+    calls = json.load(calls_f)
+
+
+def _load(src_path: str):
+    import builtins as _b
+
+    ns: dict[str, Any] = {}
+    if src_mode == "import":
+        dotted = sys.argv[5]
+        if sys.path[0] != src_path:
+            sys.path.insert(0, src_path)
+        import importlib
+
+        try:
+            dot_m = importlib.import_module(dotted)
+            return dot_m, None
+        except Exception as exc:
+            return None, (type(exc).__name__, str(exc)[:80])
+    try:
+        with Path(src_path).open(encoding="utf-8") as f:
+            code = compile(f.read(), src_path, "exec")
+        exec(code, {"__builtins__": _b.__dict__}, ns)
+        return ns, None
+    except Exception as exc:
+        return None, (type(exc).__name__, str(exc)[:80])
+
+
+def _finger(ns, call, which):
+    fn = ns.get(call["func"]) if hasattr(ns, "get") else getattr(ns, call["func"], None)
+    if fn is None:
+        _emit("no-func", which=which, func=call["func"])
+        return None
+    kwargs = {}
+    for k, expr in call["kwargs"].items():
+        try:
+            kwargs[k] = eval(expr, {"__builtins__": __builtins__}, {})
+        except Exception as exc:
+            _emit("eval-fail", which=which, func=call["func"], k=k, exc=type(exc).__name__)
+            return None
+    try:
+        signal.setitimer(signal.ITIMER_REAL, 2.0)
+        out = fn(**kwargs)
+        signal.setitimer(signal.ITIMER_REAL, 0)
+    except TimeoutError:
+        _emit("hang", which=which, func=call["func"], param=call["param"])
+        return None
+    except BaseException as exc:
+        _emit(
+            "crash",
+            which=which,
+            func=call["func"],
+            param=call["param"],
+            value=call.get("label"),
+            exc=type(exc).__name__,
+            msg=str(exc)[:100],
+        )
+        return None
+    # materialize lazy returns so we fingerprint produced output, not the wrapper
+    if hasattr(out, "__next__"):
+        try:
+            out = list(out)
+        except BaseException as exc:
+            _emit(
+                "gen-crash",
+                which=which,
+                func=call["func"],
+                param=call["param"],
+                value=call.get("label"),
+                exc=type(exc).__name__,
+            )
+            return None
+    try:
+        fp = repr(out)
+    except BaseException as exc:
+        fp = f"<repr:{type(exc).__name__}>"
+    return fp
+
+
+pre_ns, pre_err = _load(pre_path)
+if pre_err:
+    _emit("unloadable", which="pre", exc=pre_err[0], msg=pre_err[1])
+    sys.exit(0)
+post_ns, post_err = _load(post_path)
+if post_err:
+    _emit("unloadable", which="post", exc=post_err[0], msg=post_err[1])
+    sys.exit(0)
+
+for call in calls:
+    pf = _finger(pre_ns, call, "pre")
+    qf = _finger(post_ns, call, "post")
+    if pf == qf:
+        continue
+    _emit(
+        "outdiff", func=call["func"], param=call["param"], value=call.get("label"), pre=pf, post=qf
+    )