Spaces:
Sleeping
Sleeping
Download tools/lib_inspect.py from org1point1/openENV-agent: direct link, hf CLI and curl.
- Browser
- Download file 8.79 kB
-
https://huggingface.co/spaces/org1point1/openENV-agent/resolve/main/tools/lib_inspect.py
- Command line
-
hf download hf://spaces/org1point1/openENV-agent/tools/lib_inspect.py
-
curl -L -o lib_inspect.py https://huggingface.co/spaces/org1point1/openENV-agent/resolve/main/tools/lib_inspect.py
8.79 kB
| # tools/lib_inspector.py | |
| import os | |
| from dotenv import load_dotenv | |
| from openai import OpenAI | |
| from typing import Any | |
| # Load .env file | |
| load_dotenv() | |
| # --------------------------------------------------------------------------- | |
| # Static known-good mappings β checked BEFORE the LLM to avoid hallucination. | |
| # Format: (old_lib, old_func, new_lib) -> (new_func, note) | |
| # --------------------------------------------------------------------------- | |
| KNOWN_MAPPINGS: dict[tuple[str, str, str], tuple[str, str]] = { | |
| # requests β httpx (synchronous equivalents) | |
| ("requests", "get", "httpx"): ("get", "httpx.get is synchronous. Use follow_redirects= instead of allow_redirects=."), | |
| ("requests", "post", "httpx"): ("post", "httpx.post is synchronous. Same signature, no behavior change for basic use."), | |
| ("requests", "put", "httpx"): ("put", "httpx.put is synchronous."), | |
| ("requests", "patch", "httpx"): ("patch", "httpx.patch is synchronous."), | |
| ("requests", "delete", "httpx"): ("delete", "httpx.delete is synchronous."), | |
| ("requests", "head", "httpx"): ("head", "httpx.head is synchronous. Use follow_redirects=True instead of allow_redirects=True."), | |
| ("requests", "Session", "httpx"): ("Client", "httpx.Client is the sync equivalent of requests.Session. For async use httpx.AsyncClient."), | |
| ("requests", "Response", "httpx"): ("Response", "Same concept, same method names (raise_for_status, json, text, content)."), | |
| # requests adapter/retry β httpx transport | |
| ("requests.adapters", "HTTPAdapter", "httpx"): ("HTTPTransport", "httpx.HTTPTransport replaces HTTPAdapter. Pass retries=N directly."), | |
| ("urllib3.util.retry", "Retry", "httpx"): ("HTTPTransport", "Use httpx.HTTPTransport(retries=N) β no separate Retry class in httpx."), | |
| # timeout | |
| ("requests", "Timeout", "httpx"): ("Timeout", "httpx.Timeout(connect=C, read=R) replaces tuple (connect, read). Required for explicit control."), | |
| # random β secrets | |
| ("random", "choice", "secrets"): ("choice", "secrets.choice(seq) β identical signature, cryptographically secure."), | |
| ("random", "choices", "secrets"): ("token_hex", "For hex tokens use secrets.token_hex(n_bytes). For charset use [secrets.choice(charset) for _ in range(length)]."), | |
| ("random", "randint", "secrets"): ("randbelow", "secrets.randbelow(n) returns 0..n-1. For randint(a,b): secrets.randbelow(b-a+1)+a."), | |
| ("random", "getrandbits", "secrets"): ("token_bytes", "secrets.token_bytes(n) returns n random bytes. For hex: secrets.token_hex(n)."), | |
| ("random", "shuffle", "secrets"): ("SystemRandom", "Use secrets.SystemRandom().shuffle(lst) β no direct shuffle in secrets module."), | |
| ("random", "random", "secrets"): ("SystemRandom", "Use secrets.SystemRandom().random() β but prefer token_bytes for crypto use."), | |
| # tensorflow β torch (common layer mappings) | |
| ("tensorflow", "keras.layers.Dense", "torch"): ("nn.Linear", "nn.Linear(in_features, out_features). TF Dense only needs units; PyTorch requires both dims from the start."), | |
| ("tensorflow", "keras.layers.BatchNormalization", "torch"): ("nn.BatchNorm1d", "nn.BatchNorm1d(num_features). For 2D input use BatchNorm1d, for 4D images use BatchNorm2d."), | |
| ("tensorflow", "keras.layers.Dropout", "torch"): ("nn.Dropout", "nn.Dropout(p=rate). Note: TF rate is drop probability, PyTorch p is also drop probability β same semantics."), | |
| ("tensorflow", "keras.Model", "torch"): ("nn.Module", "Subclass nn.Module. Implement forward() instead of call(). No training= arg; use model.train()/model.eval() instead."), | |
| ("tensorflow", "GradientTape", "torch"): ("autograd", "Use loss.backward() + optimizer.step() + optimizer.zero_grad(). No tape context manager needed."), | |
| ("tensorflow", "keras.optimizers.Adam", "torch"): ("optim.Adam", "torch.optim.Adam(model.parameters(), lr=lr, betas=(beta_1, beta_2))."), | |
| ("tensorflow", "keras.losses.SparseCategoricalCrossentropy", "torch"): ("nn.CrossEntropyLoss", "nn.CrossEntropyLoss() takes raw LOGITS (not softmax output). Remove softmax from model output when using this loss."), | |
| ("tensorflow", "data.Dataset", "torch"): ("utils.data.DataLoader", "Use TensorDataset + DataLoader. .batch().shuffle() β DataLoader(batch_size=N, shuffle=True)."), | |
| ("tensorflow", "saved_model.save", "torch"): ("save", "torch.save(model.state_dict(), path). Load with model.load_state_dict(torch.load(path))."), | |
| ("tensorflow", "keras.models.load_model", "torch"): ("load", "model.load_state_dict(torch.load(path, weights_only=True))."), | |
| } | |
| def get_equivalent_func(old_lib: str, old_func: str, new_lib: str, failed: list[str] | None = None) -> dict[str, Any]: | |
| """ | |
| Find the equivalent function/class in new_lib for a given old_lib function. | |
| Checks static known mappings first, then falls back to LLM. | |
| Pass failed=[] with previously tried names so the LLM doesn't repeat them. | |
| """ | |
| # --- Static lookup first --- | |
| key = (old_lib, old_func, new_lib) | |
| if key in KNOWN_MAPPINGS: | |
| new_func, note = KNOWN_MAPPINGS[key] | |
| # Honour the failed list β if the static answer was tried, fall through to LLM | |
| if failed and new_func in failed: | |
| pass # fall through to LLM below | |
| else: | |
| return { | |
| "old": f"{old_lib}.{old_func}", | |
| "new": new_func, | |
| "note": note, | |
| "found": True, | |
| "source": "static_mapping", | |
| } | |
| # --- LLM fallback --- | |
| client = OpenAI( | |
| api_key=os.environ.get("OPENAI_API_KEY"), | |
| base_url=os.environ.get("API_BASE_URL", "https://api.openai.com/v1") | |
| ) | |
| prompt = _build_prompt(old_lib, old_func, new_lib, failed or []) | |
| try: | |
| response = client.chat.completions.create( | |
| model=os.environ.get("MODEL_NAME", "gpt-4o-mini"), | |
| messages=[{"role": "user", "content": prompt}], | |
| max_tokens=100 | |
| ) | |
| raw = response.choices[0].message.content | |
| equivalent, note = _parse_response(raw) | |
| return { | |
| "old": f"{old_lib}.{old_func}", | |
| "new": equivalent, | |
| "note": note, | |
| "found": equivalent is not None, | |
| "source": "llm", | |
| } | |
| except Exception as e: | |
| return { | |
| "old": f"{old_lib}.{old_func}", | |
| "new": None, | |
| "note": None, | |
| "found": False, | |
| "error": str(e), | |
| } | |
| def _build_prompt(old_lib: str, old_func: str, new_lib: str, failed: list[str]) -> str: | |
| prompt = f"""You are a Python migration expert. | |
| What is the equivalent of `{old_lib}.{old_func}` in `{new_lib}`? | |
| Respond in this exact format and nothing else: | |
| EQUIVALENT: <new_lib.equivalent_name or NONE if no equivalent exists> | |
| NOTE: <one line β most important BREAKING behavioral difference only, not general features. Focus on default value changes, renamed parameters, removed parameters, or async requirements. Or None if truly identical.>""" | |
| if failed: | |
| failed_str = ", ".join(failed) | |
| prompt += f"\n\nThese were already tried and are incorrect: {failed_str}\nDo not suggest these again." | |
| return prompt | |
| def _parse_response(raw: str) -> tuple[str | None, str | None]: | |
| equivalent = None | |
| note = None | |
| for line in raw.splitlines(): | |
| line = line.strip() | |
| if line.startswith("EQUIVALENT:"): | |
| value = line.replace("EQUIVALENT:", "").strip() | |
| equivalent = None if value.upper() == "NONE" else value | |
| elif line.startswith("NOTE:"): | |
| value = line.replace("NOTE:", "").strip() | |
| note = None if value.lower() == "none" else value | |
| return equivalent, note | |
| if __name__ == "__main__": | |
| import sys | |
| old_lib = sys.argv[1] if len(sys.argv) > 1 else "requests" | |
| old_func = sys.argv[2] if len(sys.argv) > 2 else "get" | |
| new_lib = sys.argv[3] if len(sys.argv) > 3 else "httpx" | |
| result = get_equivalent_func(old_lib, old_func, new_lib) | |
| if result["found"]: | |
| print(f"{result['old']} β {result['new']}") | |
| if result["note"]: | |
| print(f"β {result['note']}") | |
| print(f"\nNext: call func_diff('{old_lib}', '{new_lib}', '{old_func}', '{result['new'].split('.')[-1]}')") | |
| else: | |
| print(f"β No equivalent found for {result['old']} in {new_lib}") | |
| if "error" in result: | |
| print(f" Error: {result['error']}") |