calcbox 0.3.0__tar.gz

calcbox-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 calcbox contributors
+
+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.

calcbox-0.3.0/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: calcbox
+Version: 0.3.0
+Summary: Backend-agnostic math compute kernel: symbolic, numeric, units, control — with provenance in every answer
+Author: calcbox contributors
+License: MIT
+Project-URL: Repository, https://github.com/Icefox12138/calcbox
+Keywords: math,sympy,scipy,units,mcp,compute
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: symbolic
+Requires-Dist: sympy>=1.12; extra == "symbolic"
+Provides-Extra: numeric
+Requires-Dist: scipy>=1.11; extra == "numeric"
+Requires-Dist: numpy; extra == "numeric"
+Provides-Extra: units
+Requires-Dist: pint>=0.23; extra == "units"
+Provides-Extra: control
+Requires-Dist: control>=0.9; extra == "control"
+Requires-Dist: numpy; extra == "control"
+Provides-Extra: api
+Requires-Dist: fastapi>=0.110; extra == "api"
+Requires-Dist: pydantic>=2; extra == "api"
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == "mcp"
+Provides-Extra: full
+Requires-Dist: sympy>=1.12; extra == "full"
+Requires-Dist: scipy>=1.11; extra == "full"
+Requires-Dist: numpy; extra == "full"
+Requires-Dist: pint>=0.23; extra == "full"
+Requires-Dist: control>=0.9; extra == "full"
+Dynamic: license-file
+
+# calcbox
+
+Backend-agnostic math compute kernel: **symbolic, numeric, units, control** — and every
+answer carries provenance (backend, engine version, assumptions, verification, input hash).
+
+It knows nothing about teaching, documents or users. It is a calculator that can prove
+what it did.
+
+```python
+from calcbox import compute
+
+out = compute("x**2", "integrate")
+# {'result': 'x**3/3', 'backend': 'sympy', 'engine_version': '1.13.1',
+#  'verification': {'method': 'differentiate-back', 'passed': True}, ...}
+```
+
+## Why another math tool
+
+There are MCP servers that evaluate arithmetic and matrix operations. What they do not
+report is **how the answer was produced**: which backend, which engine version, which
+assumptions, and whether a second method agreed. For tutoring, for reproducible
+research notes, and for anything a human will quote, that provenance is the point.
+
+```json
+{
+  "result": "x**3/3",
+  "latex": "\\frac{x^{3}}{3}",
+  "backend": "sympy",
+  "engine_version": "1.13.1",
+  "assumptions": {"variable": "x", "domain": "real"},
+  "verification": {"method": "differentiate-back", "passed": true},
+  "disputed": false,
+  "sandbox": "audit-only",
+  "input_sha256": "9f2c…",
+  "elapsed_ms": 12.4
+}
+```
+
+## Install
+
+```bash
+pip install calcbox              # core, no backends
+pip install "calcbox[symbolic]"  # sympy  (calculus, algebra, exact values)
+pip install "calcbox[full]"      # sympy + scipy + pint + control
+pip install "calcbox[mcp]"       # MCP server (stdio)
+pip install "calcbox[api]"       # FastAPI router
+```
+
+Nothing is a hard dependency. A missing backend is reported as unavailable **with a
+reason**, never as a crash.
+
+## Use it
+
+**Python**
+
+```python
+compute("x**2", "integrate")            # indefinite
+compute("x", "integrate", target="0,1") # definite
+compute("x**3", "diff")
+compute("2+3*4", "value")
+compute("x**2-1", "solve")
+compute("sin(x)/x", "limit", point="0")
+compute("x**2", "simplify", backend="sympy")
+```
+
+**CLI**
+
+```bash
+calcbox "x**2" --op integrate
+calcbox "sin(x)/x" --op limit --point 0 --json
+```
+
+**HTTP** (optional; no auth by design — that belongs to the host)
+
+```python
+from fastapi import FastAPI
+from calcbox.api import create_router
+
+app = FastAPI()
+app.include_router(create_router())
+# GET  /v1/compute/backends
+# POST /v1/compute {"expression": "x**2", "operation": "integrate"}
+```
+
+**MCP**
+
+```json
+{
+  "mcpServers": {
+    "calcbox": {"command": "calcbox-mcp", "args": []}
+  }
+}
+```
+
+Tools: `compute`, `backends`.
+
+## Contract
+
+| Field | Meaning |
+|---|---|
+| `operation` | `simplify`, `diff`, `integrate`, `solve`, `limit`, `value`, `latex`, `factor`, `expand`, `quad`, `minimize`, `root`, `convert`, `step`, `eval`, `check` |
+| `backend` | `auto` infers from the operation; otherwise one of `sympy`/`scipy`/`pint`/`control`/`wolfram`/`lean` |
+| `verification` | method + `passed`; e.g. differentiate-back for integrals, substitute-back for solutions |
+| `disputed` | two backends disagreed (only when a cross-check runs) |
+| `sandbox` | always `audit-only` for in-process backends |
+
+Errors: `ComputeError` (bad request → 400) and `BackendUnavailable` (missing dependency
+or disabled external engine → 503).
+
+## Security
+
+**The sandbox is audit-only.** It is a set of `sys.audit` hooks, not an OS jail. Read
+[SECURITY.md](SECURITY.md) before exposing this to untrusted input. External engines
+(Wolfram, Lean) are disabled unless `CALCBOX_EXTERNAL=1`.
+
+## Status
+
+0.3.0 — all six backends wired: SymPy, SciPy, Pint, Control, and the external
+engines Wolfram and Lean (disabled unless CALCBOX_EXTERNAL=1; both fail with a
+reason when the binary is absent, never silently).
+
+15/15 parity with the implementation this was ported from, 36 tests.
+
+Every local call runs in a killable subprocess worker (~0.2-1.2 s overhead);
+CALCBOX_WORKER=0 runs in-process for debugging. External engines run in-process
+because they are already separate processes.
+
+## Releasing
+
+See [RELEASING.md](RELEASING.md): PyPI Trusted Publishing, no tokens.
+
+## License
+
+MIT.

calcbox-0.3.0/README.md

@@ -0,0 +1,134 @@
+# calcbox
+
+Backend-agnostic math compute kernel: **symbolic, numeric, units, control** — and every
+answer carries provenance (backend, engine version, assumptions, verification, input hash).
+
+It knows nothing about teaching, documents or users. It is a calculator that can prove
+what it did.
+
+```python
+from calcbox import compute
+
+out = compute("x**2", "integrate")
+# {'result': 'x**3/3', 'backend': 'sympy', 'engine_version': '1.13.1',
+#  'verification': {'method': 'differentiate-back', 'passed': True}, ...}
+```
+
+## Why another math tool
+
+There are MCP servers that evaluate arithmetic and matrix operations. What they do not
+report is **how the answer was produced**: which backend, which engine version, which
+assumptions, and whether a second method agreed. For tutoring, for reproducible
+research notes, and for anything a human will quote, that provenance is the point.
+
+```json
+{
+  "result": "x**3/3",
+  "latex": "\\frac{x^{3}}{3}",
+  "backend": "sympy",
+  "engine_version": "1.13.1",
+  "assumptions": {"variable": "x", "domain": "real"},
+  "verification": {"method": "differentiate-back", "passed": true},
+  "disputed": false,
+  "sandbox": "audit-only",
+  "input_sha256": "9f2c…",
+  "elapsed_ms": 12.4
+}
+```
+
+## Install
+
+```bash
+pip install calcbox              # core, no backends
+pip install "calcbox[symbolic]"  # sympy  (calculus, algebra, exact values)
+pip install "calcbox[full]"      # sympy + scipy + pint + control
+pip install "calcbox[mcp]"       # MCP server (stdio)
+pip install "calcbox[api]"       # FastAPI router
+```
+
+Nothing is a hard dependency. A missing backend is reported as unavailable **with a
+reason**, never as a crash.
+
+## Use it
+
+**Python**
+
+```python
+compute("x**2", "integrate")            # indefinite
+compute("x", "integrate", target="0,1") # definite
+compute("x**3", "diff")
+compute("2+3*4", "value")
+compute("x**2-1", "solve")
+compute("sin(x)/x", "limit", point="0")
+compute("x**2", "simplify", backend="sympy")
+```
+
+**CLI**
+
+```bash
+calcbox "x**2" --op integrate
+calcbox "sin(x)/x" --op limit --point 0 --json
+```
+
+**HTTP** (optional; no auth by design — that belongs to the host)
+
+```python
+from fastapi import FastAPI
+from calcbox.api import create_router
+
+app = FastAPI()
+app.include_router(create_router())
+# GET  /v1/compute/backends
+# POST /v1/compute {"expression": "x**2", "operation": "integrate"}
+```
+
+**MCP**
+
+```json
+{
+  "mcpServers": {
+    "calcbox": {"command": "calcbox-mcp", "args": []}
+  }
+}
+```
+
+Tools: `compute`, `backends`.
+
+## Contract
+
+| Field | Meaning |
+|---|---|
+| `operation` | `simplify`, `diff`, `integrate`, `solve`, `limit`, `value`, `latex`, `factor`, `expand`, `quad`, `minimize`, `root`, `convert`, `step`, `eval`, `check` |
+| `backend` | `auto` infers from the operation; otherwise one of `sympy`/`scipy`/`pint`/`control`/`wolfram`/`lean` |
+| `verification` | method + `passed`; e.g. differentiate-back for integrals, substitute-back for solutions |
+| `disputed` | two backends disagreed (only when a cross-check runs) |
+| `sandbox` | always `audit-only` for in-process backends |
+
+Errors: `ComputeError` (bad request → 400) and `BackendUnavailable` (missing dependency
+or disabled external engine → 503).
+
+## Security
+
+**The sandbox is audit-only.** It is a set of `sys.audit` hooks, not an OS jail. Read
+[SECURITY.md](SECURITY.md) before exposing this to untrusted input. External engines
+(Wolfram, Lean) are disabled unless `CALCBOX_EXTERNAL=1`.
+
+## Status
+
+0.3.0 — all six backends wired: SymPy, SciPy, Pint, Control, and the external
+engines Wolfram and Lean (disabled unless CALCBOX_EXTERNAL=1; both fail with a
+reason when the binary is absent, never silently).
+
+15/15 parity with the implementation this was ported from, 36 tests.
+
+Every local call runs in a killable subprocess worker (~0.2-1.2 s overhead);
+CALCBOX_WORKER=0 runs in-process for debugging. External engines run in-process
+because they are already separate processes.
+
+## Releasing
+
+See [RELEASING.md](RELEASING.md): PyPI Trusted Publishing, no tokens.
+
+## License
+
+MIT.

calcbox-0.3.0/calcbox/__init__.py

@@ -0,0 +1,16 @@
+"""calcbox — backend-agnostic compute kernel.
+
+    from calcbox import compute, backends
+    compute("x**2", "integrate")          # -> dict, see calcbox.contract
+    backend_status()                      # -> {"sympy": {"available": True, ...}}
+
+Every answer carries provenance: backend, engine version, assumptions,
+verification and an input hash. The sandbox is audit-only; see README.
+"""
+from .backends import backend_status, compute
+from .contract import (BackendStatus, BackendUnavailable, ComputeError,
+                       ComputeRequest, ComputeResult)
+
+__version__ = "0.3.0"
+__all__ = ["compute", "backend_status", "ComputeError", "BackendUnavailable",
+           "ComputeRequest", "ComputeResult", "BackendStatus", "__version__"]

calcbox-0.3.0/calcbox/api.py

@@ -0,0 +1,52 @@
+"""Optional HTTP surface.
+
+    from fastapi import FastAPI
+    from calcbox.api import create_router
+
+    app = FastAPI()
+    app.include_router(create_router())
+
+The routes mirror the contract exactly; they carry no authentication, because
+that is the host's job (calcbox has no notion of users).
+"""
+from typing import Any, Dict, Optional
+
+from . import backends as _backends
+from .contract import BackendUnavailable, ComputeError
+
+
+def create_router():
+    from fastapi import APIRouter, HTTPException
+    from pydantic import BaseModel
+
+    router = APIRouter()
+
+    class ComputeIn(BaseModel):
+        expression: str
+        operation: str = "simplify"
+        variable: str = "x"
+        point: str = "0"
+        target: Optional[str] = None
+        data: Optional[Dict[str, Any]] = None
+        timeout: float = 8.0
+        backend: str = "auto"
+
+    @router.get("/v1/compute/backends")
+    def get_backends():
+        return {"backends": _backends.backend_status()}
+
+    @router.post("/v1/compute")
+    def post_compute(body: ComputeIn):
+        try:
+            return _backends.compute(body.expression, operation=body.operation,
+                                     variable=body.variable, point=body.point,
+                                     target=body.target, data=body.data,
+                                     timeout=body.timeout, backend=body.backend)
+        except BackendUnavailable as e:
+            raise HTTPException(status_code=503, detail={"code": "backend_unavailable",
+                                                         "detail": str(e)})
+        except ComputeError as e:
+            raise HTTPException(status_code=400, detail={"code": "bad_request",
+                                                         "detail": str(e)})
+
+    return router