tatvastack-codeforge 0.1.0__tar.gz

tatvastack_codeforge-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TatvaStack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tatvastack_codeforge-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: tatvastack-codeforge
+Version: 0.1.0
+Summary: Official CodeForge SDK: run Python, JavaScript, Java and C++ in isolated, network-free sandboxes with one API.
+Author-email: TatvaStack <bhaskar@tatvastack.com>
+License-Expression: MIT
+Project-URL: Homepage, https://codeforge.tatvastack.com
+Project-URL: Documentation, https://codeforge.tatvastack.com/docs/
+Keywords: codeforge,code execution,code execution api,sandbox,compiler api,online compiler,code runner,judge
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: certifi
+Requires-Dist: certifi; extra == "certifi"
+Dynamic: license-file
+
+# CodeForge SDK for Python
+
+Run Python, JavaScript, Java and C++ in isolated, network-free sandboxes. Python 3.8+, standard library only.
+
+```bash
+pip install tatvastack-codeforge
+```
+
+The package installs as `tatvastack-codeforge` and imports as `codeforge`.
+
+```python
+import os
+from codeforge import CodeForge
+
+cf = CodeForge(api_key=os.environ["CODEFORGE_API_KEY"])  # keep keys server-side
+
+result = cf.run("python", "print(input()[::-1])", stdin="hello")
+print(result["status"], result["stdout"])  # SUCCEEDED olleh
+```
+
+- `run(...)` submits and waits; `submit(...)` + `wait(id)` / `get(id)` for your own flow; `usage()` for quota.
+- Every `submit` sends an `Idempotency-Key` (a UUID, or pass `idempotency_key=`). Network errors, 5xx and `CONCURRENCY_LIMIT` are retried with the **same** key, so a retry never runs code twice or charges twice.
+- A compile error or non-zero exit is a normal result: check `result["status"]`. Exceptions are `CodeForgeError` with `code`, `status`, `request_id` and `retryable`.
+
+```python
+from codeforge import CodeForgeError
+try:
+    cf.run("cpp", source, time_ms=2000)
+except CodeForgeError as e:
+    if e.code == "QUOTA_EXCEEDED":
+        print("Resets at", e.details["resetsAt"])
+    else:
+        raise
+```
+
+**TLS on macOS:** python.org builds ship without CA certificates. If you see `TLS_ERROR`, run `pip install "tatvastack-codeforge[certifi]"` (the SDK uses it automatically) or *Install Certificates.command*. Behind a corporate proxy, pass `ssl_context=ssl.create_default_context(cafile=...)`.
+
+Get an API key from the [CodeForge dashboard](https://codeforge.tatvastack.com/app/) (private beta). Full API reference: https://codeforge.tatvastack.com/docs/
+
+MIT licensed. Made by [TatvaStack](https://tatvastack.com).

tatvastack_codeforge-0.1.0/README.md

@@ -0,0 +1,40 @@
+# CodeForge SDK for Python
+
+Run Python, JavaScript, Java and C++ in isolated, network-free sandboxes. Python 3.8+, standard library only.
+
+```bash
+pip install tatvastack-codeforge
+```
+
+The package installs as `tatvastack-codeforge` and imports as `codeforge`.
+
+```python
+import os
+from codeforge import CodeForge
+
+cf = CodeForge(api_key=os.environ["CODEFORGE_API_KEY"])  # keep keys server-side
+
+result = cf.run("python", "print(input()[::-1])", stdin="hello")
+print(result["status"], result["stdout"])  # SUCCEEDED olleh
+```
+
+- `run(...)` submits and waits; `submit(...)` + `wait(id)` / `get(id)` for your own flow; `usage()` for quota.
+- Every `submit` sends an `Idempotency-Key` (a UUID, or pass `idempotency_key=`). Network errors, 5xx and `CONCURRENCY_LIMIT` are retried with the **same** key, so a retry never runs code twice or charges twice.
+- A compile error or non-zero exit is a normal result: check `result["status"]`. Exceptions are `CodeForgeError` with `code`, `status`, `request_id` and `retryable`.
+
+```python
+from codeforge import CodeForgeError
+try:
+    cf.run("cpp", source, time_ms=2000)
+except CodeForgeError as e:
+    if e.code == "QUOTA_EXCEEDED":
+        print("Resets at", e.details["resetsAt"])
+    else:
+        raise
+```
+
+**TLS on macOS:** python.org builds ship without CA certificates. If you see `TLS_ERROR`, run `pip install "tatvastack-codeforge[certifi]"` (the SDK uses it automatically) or *Install Certificates.command*. Behind a corporate proxy, pass `ssl_context=ssl.create_default_context(cafile=...)`.
+
+Get an API key from the [CodeForge dashboard](https://codeforge.tatvastack.com/app/) (private beta). Full API reference: https://codeforge.tatvastack.com/docs/
+
+MIT licensed. Made by [TatvaStack](https://tatvastack.com).

tatvastack_codeforge-0.1.0/codeforge/__init__.py

@@ -0,0 +1,169 @@
+"""CodeForge SDK for Python 3.8+. Standard library only.
+
+    from codeforge import CodeForge
+    cf = CodeForge(api_key=os.environ["CODEFORGE_API_KEY"])
+    result = cf.run("python", "print(6 * 7)")
+    print(result["status"], result["stdout"])   # SUCCEEDED 42
+"""
+
+from __future__ import annotations
+
+import json
+import random
+import ssl
+import time
+import urllib.error
+import urllib.request
+import uuid
+from typing import Any, Dict, Optional
+
+__all__ = ["CodeForge", "CodeForgeError", "DEFAULT_BASE_URL", "TERMINAL_STATUSES"]
+__version__ = "0.1.0"
+
+DEFAULT_BASE_URL = "https://api.tatvastack.com"
+TERMINAL_STATUSES = frozenset({"SUCCEEDED", "COMPILE_ERROR", "RUNTIME_ERROR", "TIMED_OUT", "PLATFORM_ERROR"})
+
+
+class CodeForgeError(Exception):
+    """An API error, or a client-side failure (NETWORK_ERROR, WAIT_TIMEOUT)."""
+
+    def __init__(self, message: str, code: str = "UNKNOWN", status: Optional[int] = None,
+                 request_id: Optional[str] = None, retryable: bool = False, details: Optional[dict] = None):
+        super().__init__(message)
+        self.message = message
+        self.code = code
+        self.status = status
+        self.request_id = request_id
+        self.retryable = retryable
+        self.details = details or {}
+
+    def __repr__(self) -> str:
+        return f"CodeForgeError(code={self.code!r}, status={self.status}, request_id={self.request_id!r}, message={self.message!r})"
+
+
+def _default_ssl_context() -> ssl.SSLContext:
+    """System CA store, or certifi's when installed (fixes python.org builds on macOS)."""
+    try:
+        import certifi  # type: ignore
+        return ssl.create_default_context(cafile=certifi.where())
+    except ImportError:
+        return ssl.create_default_context()
+
+
+_TLS_HINT = (
+    "TLS certificate verification failed. Your Python has no trusted CA certificates. "
+    "Fix: `pip install certifi` (the SDK uses it automatically), or on macOS run "
+    "'Install Certificates.command' from your Python folder, or pass ssl_context=..."
+)
+
+
+def _backoff(attempt: int) -> float:
+    return min(8.0, 0.3 * 2 ** (attempt - 1)) * (0.5 + random.random() / 2)
+
+
+class CodeForge:
+    """Client for the CodeForge execution API.
+
+    Args:
+        api_key: Your ``cf_live_`` key. Keep it on your server.
+        base_url: API origin.
+        max_retries: Retries for network errors, 5xx responses and concurrency limits.
+        request_timeout: Seconds per HTTP request.
+        ssl_context: Custom TLS settings (e.g. a corporate CA bundle). Defaults to the system
+            store, or certifi's if installed.
+    """
+
+    def __init__(self, api_key: str, base_url: str = DEFAULT_BASE_URL, max_retries: int = 3, request_timeout: float = 15.0,
+                 ssl_context: Optional[ssl.SSLContext] = None):
+        if not api_key:
+            raise CodeForgeError("api_key is required", code="CONFIGURATION")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.max_retries = max_retries
+        self.request_timeout = request_timeout
+        self.ssl_context = ssl_context or _default_ssl_context()
+
+    def _request(self, method: str, path: str, body: Optional[dict] = None, headers: Optional[Dict[str, str]] = None) -> Any:
+        data = json.dumps(body).encode() if body is not None else None
+        all_headers = {"Authorization": f"Bearer {self.api_key}", "User-Agent": f"codeforge-python/{__version__}", "Accept": "application/json"}
+        if data is not None:
+            all_headers["Content-Type"] = "application/json"
+        all_headers.update(headers or {})
+
+        attempt = 0
+        while True:
+            attempt += 1
+            req = urllib.request.Request(self.base_url + path, data=data, method=method, headers=all_headers)
+            try:
+                with urllib.request.urlopen(req, timeout=self.request_timeout, context=self.ssl_context) as res:
+                    text = res.read().decode("utf-8")
+                    return json.loads(text) if text else None
+            except urllib.error.HTTPError as http_err:
+                text = http_err.read().decode("utf-8", "replace")
+                try:
+                    payload = json.loads(text) if text else {}
+                except ValueError:
+                    payload = {}
+                e = payload.get("error", {}) if isinstance(payload, dict) else {}
+                error = CodeForgeError(
+                    e.get("message") or f"HTTP {http_err.code}",
+                    code=e.get("code") or f"HTTP_{http_err.code}",
+                    status=http_err.code,
+                    request_id=e.get("requestId") or http_err.headers.get("x-request-id"),
+                    retryable=e.get("retryable", http_err.code >= 500),
+                    details=e,
+                )
+                if error.retryable and attempt <= self.max_retries:
+                    time.sleep(_backoff(attempt))
+                    continue
+                raise error from None
+            except (urllib.error.URLError, TimeoutError, ConnectionError) as net_err:
+                reason = getattr(net_err, "reason", net_err)
+                if isinstance(reason, ssl.SSLCertVerificationError):
+                    # Retrying can't fix a local trust-store problem.
+                    raise CodeForgeError(_TLS_HINT, code="TLS_ERROR", retryable=False) from None
+                # Safe to retry: POSTs carry an Idempotency-Key, so a retry never runs code twice.
+                if attempt <= self.max_retries:
+                    time.sleep(_backoff(attempt))
+                    continue
+                raise CodeForgeError(f"Network error: {net_err}", code="NETWORK_ERROR", retryable=True) from None
+
+    def submit(self, language: str, source: str, stdin: Optional[str] = None, time_ms: Optional[int] = None,
+               idempotency_key: Optional[str] = None) -> dict:
+        """Queue an execution and return immediately: ``{"executionId", "status": "QUEUED", ...}``."""
+        body: Dict[str, Any] = {"language": language, "source": source}
+        if stdin is not None:
+            body["stdin"] = stdin
+        if time_ms is not None:
+            body["limits"] = {"timeMs": time_ms}
+        return self._request("POST", "/v1/executions", body, {"Idempotency-Key": idempotency_key or str(uuid.uuid4())})
+
+    def get(self, execution_id: str) -> dict:
+        """Fetch an execution's current state."""
+        return self._request("GET", f"/v1/executions/{urllib.request.quote(execution_id, safe='')}")
+
+    def wait(self, execution_id: str, poll_interval: float = 0.5, timeout: float = 120.0) -> dict:
+        """Poll until the execution finishes and return it."""
+        deadline = time.monotonic() + timeout
+        while True:
+            execution = self.get(execution_id)
+            if execution.get("status") in TERMINAL_STATUSES:
+                return execution
+            if time.monotonic() + poll_interval > deadline:
+                raise CodeForgeError(f"Execution {execution_id} still {execution.get('status')} after {timeout}s",
+                                     code="WAIT_TIMEOUT", retryable=True, details={"executionId": execution_id})
+            time.sleep(poll_interval)
+
+    def run(self, language: str, source: str, stdin: Optional[str] = None, time_ms: Optional[int] = None,
+            idempotency_key: Optional[str] = None, poll_interval: float = 0.5, timeout: float = 120.0) -> dict:
+        """Submit code and wait for the result.
+
+        A non-zero exit or compile error is a normal result (check ``status``), not an exception;
+        exceptions mean the request itself failed.
+        """
+        accepted = self.submit(language, source, stdin=stdin, time_ms=time_ms, idempotency_key=idempotency_key)
+        return self.wait(accepted["executionId"], poll_interval=poll_interval, timeout=timeout)
+
+    def usage(self) -> dict:
+        """This month's quota, current concurrency and 30-day daily usage."""
+        return self._request("GET", "/v1/usage")

tatvastack_codeforge-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+# PyPI's "codeforge" name belongs to an unrelated project; the import name is still `codeforge`.
+name = "tatvastack-codeforge"
+version = "0.1.0"
+description = "Official CodeForge SDK: run Python, JavaScript, Java and C++ in isolated, network-free sandboxes with one API."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "TatvaStack", email = "bhaskar@tatvastack.com" }]
+keywords = ["codeforge", "code execution", "code execution api", "sandbox", "compiler api", "online compiler", "code runner", "judge"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Libraries",
+  "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+# Fixes certificate errors on python.org builds for macOS; used automatically when installed.
+certifi = ["certifi"]
+
+[project.urls]
+Homepage = "https://codeforge.tatvastack.com"
+Documentation = "https://codeforge.tatvastack.com/docs/"
+
+[tool.setuptools]
+packages = ["codeforge"]
+
+[tool.setuptools.package-data]
+codeforge = ["py.typed"]

tatvastack_codeforge-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tatvastack_codeforge-0.1.0/tatvastack_codeforge.egg-info/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: tatvastack-codeforge
+Version: 0.1.0
+Summary: Official CodeForge SDK: run Python, JavaScript, Java and C++ in isolated, network-free sandboxes with one API.
+Author-email: TatvaStack <bhaskar@tatvastack.com>
+License-Expression: MIT
+Project-URL: Homepage, https://codeforge.tatvastack.com
+Project-URL: Documentation, https://codeforge.tatvastack.com/docs/
+Keywords: codeforge,code execution,code execution api,sandbox,compiler api,online compiler,code runner,judge
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: certifi
+Requires-Dist: certifi; extra == "certifi"
+Dynamic: license-file
+
+# CodeForge SDK for Python
+
+Run Python, JavaScript, Java and C++ in isolated, network-free sandboxes. Python 3.8+, standard library only.
+
+```bash
+pip install tatvastack-codeforge
+```
+
+The package installs as `tatvastack-codeforge` and imports as `codeforge`.
+
+```python
+import os
+from codeforge import CodeForge
+
+cf = CodeForge(api_key=os.environ["CODEFORGE_API_KEY"])  # keep keys server-side
+
+result = cf.run("python", "print(input()[::-1])", stdin="hello")
+print(result["status"], result["stdout"])  # SUCCEEDED olleh
+```
+
+- `run(...)` submits and waits; `submit(...)` + `wait(id)` / `get(id)` for your own flow; `usage()` for quota.
+- Every `submit` sends an `Idempotency-Key` (a UUID, or pass `idempotency_key=`). Network errors, 5xx and `CONCURRENCY_LIMIT` are retried with the **same** key, so a retry never runs code twice or charges twice.
+- A compile error or non-zero exit is a normal result: check `result["status"]`. Exceptions are `CodeForgeError` with `code`, `status`, `request_id` and `retryable`.
+
+```python
+from codeforge import CodeForgeError
+try:
+    cf.run("cpp", source, time_ms=2000)
+except CodeForgeError as e:
+    if e.code == "QUOTA_EXCEEDED":
+        print("Resets at", e.details["resetsAt"])
+    else:
+        raise
+```
+
+**TLS on macOS:** python.org builds ship without CA certificates. If you see `TLS_ERROR`, run `pip install "tatvastack-codeforge[certifi]"` (the SDK uses it automatically) or *Install Certificates.command*. Behind a corporate proxy, pass `ssl_context=ssl.create_default_context(cafile=...)`.
+
+Get an API key from the [CodeForge dashboard](https://codeforge.tatvastack.com/app/) (private beta). Full API reference: https://codeforge.tatvastack.com/docs/
+
+MIT licensed. Made by [TatvaStack](https://tatvastack.com).

tatvastack_codeforge-0.1.0/tatvastack_codeforge.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+codeforge/__init__.py
+codeforge/py.typed
+tatvastack_codeforge.egg-info/PKG-INFO
+tatvastack_codeforge.egg-info/SOURCES.txt
+tatvastack_codeforge.egg-info/dependency_links.txt
+tatvastack_codeforge.egg-info/requires.txt
+tatvastack_codeforge.egg-info/top_level.txt
+tests/test_sdk.py

tatvastack_codeforge-0.1.0/tatvastack_codeforge.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tatvastack_codeforge-0.1.0/tatvastack_codeforge.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[certifi]
+certifi

tatvastack_codeforge-0.1.0/tatvastack_codeforge.egg-info/top_level.txt

@@ -0,0 +1 @@
+codeforge

tatvastack_codeforge-0.1.0/tests/test_sdk.py

@@ -0,0 +1,126 @@
+"""Offline tests against a local fake API that behaves like CodeForge (no network, no AWS)."""
+
+import json
+import os
+import sys
+import threading
+import unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+from codeforge import CodeForge, CodeForgeError  # noqa: E402
+
+
+class FakeApi:
+    def __init__(self, handler):
+        self.calls = []
+        outer = self
+
+        class Handler(BaseHTTPRequestHandler):
+            def log_message(self, *args):
+                pass
+
+            def _serve(self):
+                length = int(self.headers.get("Content-Length") or 0)
+                body = json.loads(self.rfile.read(length)) if length else None
+                outer.calls.append({"method": self.command, "path": self.path, "headers": dict(self.headers), "body": body})
+                status, payload = handler(self.command, len(outer.calls), body)
+                data = json.dumps(payload).encode()
+                self.send_response(status)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(data)))
+                self.end_headers()
+                self.wfile.write(data)
+
+            do_GET = do_POST = _serve
+
+        self.server = HTTPServer(("127.0.0.1", 0), Handler)
+        self.url = f"http://127.0.0.1:{self.server.server_address[1]}"
+        threading.Thread(target=self.server.serve_forever, daemon=True).start()
+
+    def close(self):
+        self.server.shutdown()
+
+
+def err(code, retryable, **extra):
+    return {"error": {"code": code, "message": code, "requestId": "req_test", "retryable": retryable, **extra}}
+
+
+class SdkTest(unittest.TestCase):
+    def test_run_submits_with_idempotency_key_and_polls(self):
+        state = {"polls": 0}
+
+        def handler(method, n, body):
+            if method == "POST":
+                return 202, {"executionId": "exe_1", "status": "QUEUED"}
+            state["polls"] += 1
+            return 200, {"executionId": "exe_1", "status": "RUNNING" if state["polls"] < 3 else "SUCCEEDED", "stdout": "42\n", "exitCode": 0}
+
+        api = FakeApi(handler)
+        try:
+            cf = CodeForge(api_key="cf_live_x", base_url=api.url)
+            result = cf.run("python", "print(42)", time_ms=2000, poll_interval=0.01)
+            self.assertEqual(result["status"], "SUCCEEDED")
+            self.assertEqual(result["stdout"], "42\n")
+            post = api.calls[0]
+            self.assertEqual(post["headers"]["Authorization"], "Bearer cf_live_x")
+            self.assertRegex(post["headers"]["Idempotency-Key"], r"^[0-9a-f-]{36}$")
+            self.assertEqual(post["body"], {"language": "python", "source": "print(42)", "limits": {"timeMs": 2000}})
+            self.assertEqual(len(api.calls), 4)
+        finally:
+            api.close()
+
+    def test_retries_reuse_the_same_idempotency_key(self):
+        def handler(method, n, body):
+            if n == 1:
+                return 500, err("INTERNAL_ERROR", True)
+            if n == 2:
+                return 429, err("CONCURRENCY_LIMIT", True)
+            return 202, {"executionId": "exe_2", "status": "QUEUED"}
+
+        api = FakeApi(handler)
+        try:
+            accepted = CodeForge(api_key="k", base_url=api.url).submit("cpp", "int main(){}")
+            self.assertEqual(accepted["executionId"], "exe_2")
+            self.assertEqual(len(api.calls), 3)
+            self.assertEqual(len({c["headers"]["Idempotency-Key"] for c in api.calls}), 1)
+        finally:
+            api.close()
+
+    def test_non_retryable_error_is_raised_with_details(self):
+        api = FakeApi(lambda m, n, b: (429, err("QUOTA_EXCEEDED", False, resetsAt="2026-12-01T00:00:00Z")))
+        try:
+            with self.assertRaises(CodeForgeError) as ctx:
+                CodeForge(api_key="k", base_url=api.url).submit("python", "x")
+            e = ctx.exception
+            self.assertEqual((e.code, e.status, e.request_id, e.retryable), ("QUOTA_EXCEEDED", 429, "req_test", False))
+            self.assertEqual(e.details["resetsAt"], "2026-12-01T00:00:00Z")
+            self.assertEqual(len(api.calls), 1)
+        finally:
+            api.close()
+
+    def test_wait_times_out(self):
+        api = FakeApi(lambda m, n, b: (200, {"executionId": "exe_3", "status": "QUEUED"}))
+        try:
+            with self.assertRaises(CodeForgeError) as ctx:
+                CodeForge(api_key="k", base_url=api.url).wait("exe_3", poll_interval=0.01, timeout=0.05)
+            self.assertEqual(ctx.exception.code, "WAIT_TIMEOUT")
+        finally:
+            api.close()
+
+    def test_custom_idempotency_key(self):
+        api = FakeApi(lambda m, n, b: (202, {"executionId": "exe_4", "status": "QUEUED"}))
+        try:
+            CodeForge(api_key="k", base_url=api.url).submit("java", "x", idempotency_key="order-123")
+            self.assertEqual(api.calls[0]["headers"]["Idempotency-Key"], "order-123")
+        finally:
+            api.close()
+
+    def test_network_error(self):
+        with self.assertRaises(CodeForgeError) as ctx:
+            CodeForge(api_key="k", base_url="http://127.0.0.1:1", max_retries=1).get("exe_x")
+        self.assertEqual(ctx.exception.code, "NETWORK_ERROR")
+
+
+if __name__ == "__main__":
+    unittest.main()