talocode-calclane 0.3.0__py3-none-any.whl

calclane/__init__.py

@@ -0,0 +1,12 @@
+"""CalcLane — calculator engine client for agents (Talocode)."""
+
+__version__ = "0.3.0"
+
+from .client import CalcLaneClient, CalcLaneError, create_calclane_client
+
+__all__ = [
+    "CalcLaneClient",
+    "CalcLaneError",
+    "create_calclane_client",
+    "__version__",
+]

calclane/__main__.py

@@ -0,0 +1,80 @@
+"""CLI: `calclane` / `python -m calclane`."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from . import __version__
+from .client import CalcLaneClient, CalcLaneError
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="calclane",
+        description="CalcLane — calculator for agents (Talocode)",
+    )
+    parser.add_argument("--version", action="version", version=__version__)
+    parser.add_argument("--base-url", default=None)
+    parser.add_argument("--api-key", default=None)
+    parser.add_argument(
+        "--remote",
+        action="store_true",
+        help="Use hosted API at TALOCODE_BASE_URL",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    sub.add_parser("health")
+    sub.add_parser("pricing")
+    sub.add_parser("capabilities")
+
+    ev = sub.add_parser("eval", aliases=["evaluate"], help="Evaluate expression")
+    ev.add_argument("expression", nargs="?", default=None)
+    ev.add_argument("-e", "--expr", dest="expr", default=None)
+    ev.add_argument("--mode", choices=["standard", "scientific"], default="scientific")
+    ev.add_argument("--angle", choices=["deg", "rad", "grad"], default="deg")
+
+    args = parser.parse_args(argv)
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    client = CalcLaneClient(
+        api_key=args.api_key,
+        base_url=args.base_url,
+        prefer_local=not args.remote,
+    )
+
+    try:
+        if args.command == "health":
+            result = client.health(remote=args.remote)
+        elif args.command == "pricing":
+            result = client.pricing(remote=args.remote)
+        elif args.command == "capabilities":
+            result = client.capabilities(remote=args.remote)
+        elif args.command in ("eval", "evaluate"):
+            expression = args.expression or args.expr
+            if not expression:
+                print("expression required", file=sys.stderr)
+                sys.exit(1)
+            result = client.evaluate(
+                expression,
+                mode=args.mode,
+                angle=args.angle,
+                remote=args.remote,
+            )
+            if not result.get("ok"):
+                print(json.dumps(result, indent=2))
+                sys.exit(2)
+        else:
+            print(f"Unknown command: {args.command}", file=sys.stderr)
+            sys.exit(1)
+        print(json.dumps(result, indent=2))
+    except CalcLaneError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

calclane/client.py

@@ -0,0 +1,410 @@
+"""CalcLane REST client + local expression evaluator (stdlib only)."""
+
+from __future__ import annotations
+
+import ast
+import json
+import math
+import operator
+import os
+import re
+import urllib.error
+import urllib.request
+from typing import Any
+
+
+class CalcLaneError(Exception):
+    """Raised when evaluation or the hosted API fails."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        code: str | None = None,
+        status: int | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.status = status
+
+
+_BINOPS = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+    ast.Mod: operator.mod,
+    ast.Pow: operator.pow,
+}
+
+_FUNCS = {
+    "sin": math.sin,
+    "cos": math.cos,
+    "tan": math.tan,
+    "asin": math.asin,
+    "acos": math.acos,
+    "atan": math.atan,
+    "log": math.log10,
+    "ln": math.log,
+    "sqrt": math.sqrt,
+    "cbrt": lambda x: x ** (1 / 3) if x >= 0 else -((-x) ** (1 / 3)),
+    "abs": abs,
+    "floor": math.floor,
+    "ceil": math.ceil,
+    "round": round,
+    "exp": math.exp,
+    "fact": math.factorial,
+    "factorial": math.factorial,
+}
+
+
+def _to_radians(value: float, angle: str) -> float:
+    if angle == "deg":
+        return math.radians(value)
+    if angle == "grad":
+        return value * math.pi / 200
+    return value
+
+
+def _from_radians(value: float, angle: str) -> float:
+    if angle == "deg":
+        return math.degrees(value)
+    if angle == "grad":
+        return value * 200 / math.pi
+    return value
+
+
+class _SafeEval(ast.NodeVisitor):
+    def __init__(self, angle: str = "deg", mode: str = "scientific") -> None:
+        self.angle = angle
+        self.mode = mode
+
+    def visit(self, node: ast.AST) -> Any:  # type: ignore[override]
+        return super().visit(node)
+
+    def eval(self, expression: str) -> float:
+        # normalize ^ to ** for Python AST
+        expr = expression.strip().replace("^", "**")
+        expr = re.sub(r"\bpi\b", "pi", expr, flags=re.I)
+        tree = ast.parse(expr, mode="eval")
+        return float(self.visit(tree.body))
+
+    def visit_Expression(self, node: ast.Expression) -> Any:
+        return self.visit(node.body)
+
+    def visit_Constant(self, node: ast.Constant) -> Any:
+        if isinstance(node.value, (int, float)):
+            return float(node.value)
+        raise CalcLaneError("Invalid constant")
+
+    def visit_Name(self, node: ast.Name) -> Any:
+        n = node.id.lower()
+        if n == "pi":
+            return math.pi
+        if n == "e":
+            return math.e
+        raise CalcLaneError(f"Unknown identifier: {node.id}")
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> Any:
+        v = self.visit(node.operand)
+        if isinstance(node.op, ast.UAdd):
+            return +v
+        if isinstance(node.op, ast.USub):
+            return -v
+        raise CalcLaneError("Unsupported unary operator")
+
+    def visit_BinOp(self, node: ast.BinOp) -> Any:
+        left = self.visit(node.left)
+        right = self.visit(node.right)
+        op_type = type(node.op)
+        if op_type not in _BINOPS:
+            raise CalcLaneError("Unsupported operator")
+        if op_type is ast.Div and right == 0:
+            raise CalcLaneError("Cannot divide by zero")
+        if op_type is ast.Mod and right == 0:
+            raise CalcLaneError("Cannot divide by zero")
+        result = _BINOPS[op_type](left, right)
+        if not math.isfinite(result):
+            raise CalcLaneError("Overflow")
+        return result
+
+    def visit_Call(self, node: ast.Call) -> Any:
+        if not isinstance(node.func, ast.Name):
+            raise CalcLaneError("Invalid function call")
+        name = node.func.id.lower()
+        if name not in _FUNCS:
+            raise CalcLaneError(f"Unknown function: {name}")
+        if len(node.args) != 1 or node.keywords:
+            raise CalcLaneError(f"{name} expects one argument")
+        x = float(self.visit(node.args[0]))
+        if name in ("sin", "cos", "tan"):
+            x = _to_radians(x, self.angle)
+            result = _FUNCS[name](x)
+        elif name in ("asin", "acos", "atan"):
+            result = _from_radians(_FUNCS[name](x), self.angle)
+        else:
+            if name in ("fact", "factorial"):
+                if not float(x).is_integer() or x < 0:
+                    raise CalcLaneError("Invalid factorial input")
+                result = float(math.factorial(int(x)))
+            else:
+                result = float(_FUNCS[name](x))
+        if not math.isfinite(result):
+            raise CalcLaneError("Invalid input")
+        return result
+
+    def visit_Expr(self, node: ast.Expr) -> Any:
+        return self.visit(node.value)
+
+    def generic_visit(self, node: ast.AST) -> Any:
+        raise CalcLaneError(f"Unsupported expression node: {type(node).__name__}")
+
+
+def evaluate_local(
+    expression: str,
+    *,
+    mode: str = "scientific",
+    angle: str = "deg",
+) -> dict[str, Any]:
+    """Evaluate expression offline (stdlib). Scientific uses Python precedence."""
+    expr = (expression or "").strip()
+    if not expr:
+        return {
+            "ok": False,
+            "expression": expr,
+            "result": None,
+            "display": "expression is required",
+            "mode": mode,
+            "angle": angle,
+            "engine": "calclane",
+            "version": "0.3.0",
+            "error": "expression is required",
+        }
+    try:
+        # Standard mode: left-to-right by reducing operators sequentially is hard with AST.
+        # For standard we still use scientific-safe AST; note documented difference.
+        value = _SafeEval(angle=angle, mode=mode).eval(expr)
+        # pretty display
+        if abs(value) != 0 and (abs(value) >= 1e16 or abs(value) < 1e-10):
+            display = f"{value:.10e}".replace("e+", "e")
+        else:
+            display = f"{value:.15g}"
+        return {
+            "ok": True,
+            "expression": expr,
+            "result": value,
+            "display": display,
+            "mode": mode,
+            "angle": angle,
+            "engine": "calclane",
+            "version": "0.3.0",
+        }
+    except CalcLaneError as e:
+        return {
+            "ok": False,
+            "expression": expr,
+            "result": None,
+            "display": str(e),
+            "mode": mode,
+            "angle": angle,
+            "engine": "calclane",
+            "version": "0.3.0",
+            "error": str(e),
+        }
+    except Exception as e:  # noqa: BLE001
+        return {
+            "ok": False,
+            "expression": expr,
+            "result": None,
+            "display": str(e),
+            "mode": mode,
+            "angle": angle,
+            "engine": "calclane",
+            "version": "0.3.0",
+            "error": str(e),
+        }
+
+
+class CalcLaneClient:
+    """Python client for Talocode CalcLane (`/v1/calclane/*`) + local eval."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        *,
+        prefer_local: bool = True,
+        timeout: float = 30.0,
+    ) -> None:
+        self.api_key = api_key or os.environ.get("TALOCODE_API_KEY")
+        self.base_url = (
+            base_url
+            or os.environ.get("TALOCODE_BASE_URL")
+            or "https://api.talocode.site"
+        ).rstrip("/")
+        self.prefer_local = prefer_local
+        self.timeout = timeout
+
+    def _resolve_path(self, path: str) -> str:
+        if self.base_url.endswith("/calclane") and (
+            path == "/v1/calclane" or path.startswith("/v1/calclane/")
+        ):
+            rest = path[len("/v1/calclane") :] or "/health"
+            return rest if rest.startswith("/") else f"/{rest}"
+        return path
+
+    def _headers(self) -> dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+            headers["X-Api-Key"] = self.api_key
+        return headers
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        url = f"{self.base_url}{self._resolve_path(path)}"
+        data = json.dumps(body).encode("utf-8") if body is not None else None
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers=self._headers(),
+            method=method,
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read().decode("utf-8")
+                if not raw:
+                    return {}
+                return json.loads(raw)
+        except urllib.error.HTTPError as e:
+            code: str | None = None
+            msg = str(e)
+            try:
+                detail = json.loads(e.read().decode("utf-8"))
+                if isinstance(detail, dict):
+                    err = detail.get("error")
+                    if isinstance(err, dict):
+                        msg = err.get("message") or msg
+                        code = err.get("code")
+                    elif isinstance(err, str):
+                        msg = err
+                    code = code or detail.get("code")
+            except Exception:
+                pass
+            raise CalcLaneError(msg, code=code, status=e.code) from e
+        except urllib.error.URLError as e:
+            raise CalcLaneError(f"Request failed: {e.reason}") from e
+
+    def evaluate_local(
+        self,
+        expression: str,
+        *,
+        mode: str = "scientific",
+        angle: str = "deg",
+    ) -> dict[str, Any]:
+        return evaluate_local(expression, mode=mode, angle=angle)
+
+    def evaluate(
+        self,
+        expression: str,
+        *,
+        mode: str = "scientific",
+        angle: str = "deg",
+        remote: bool = False,
+        fe: bool | None = None,
+    ) -> dict[str, Any]:
+        if remote or (not self.prefer_local and self.api_key):
+            return self.evaluate_remote(expression, mode=mode, angle=angle, fe=fe)
+        return self.evaluate_local(expression, mode=mode, angle=angle)
+
+    def evaluate_remote(
+        self,
+        expression: str,
+        *,
+        mode: str = "scientific",
+        angle: str = "deg",
+        fe: bool | None = None,
+    ) -> dict[str, Any]:
+        if not self.api_key:
+            raise CalcLaneError(
+                "TALOCODE_API_KEY required for hosted evaluate",
+                code="MISSING_API_KEY",
+                status=401,
+            )
+        body: dict[str, Any] = {
+            "expression": expression,
+            "mode": mode,
+            "angle": angle,
+        }
+        if fe is not None:
+            body["fe"] = fe
+        return self._request("POST", "/v1/calclane/evaluate", body)
+
+    def dispatch(
+        self,
+        commands: list[dict[str, Any]],
+        *,
+        mode: str | None = None,
+        angle: str | None = None,
+        remote: bool = False,
+    ) -> dict[str, Any]:
+        if remote or (not self.prefer_local and self.api_key):
+            if not self.api_key:
+                raise CalcLaneError(
+                    "TALOCODE_API_KEY required for hosted dispatch",
+                    code="MISSING_API_KEY",
+                    status=401,
+                )
+            body: dict[str, Any] = {"commands": commands}
+            if mode:
+                body["mode"] = mode
+            if angle:
+                body["angle"] = angle
+            return self._request("POST", "/v1/calclane/dispatch", body)
+        raise CalcLaneError(
+            "Local dispatch requires the Node engine; use evaluate_local or remote=True",
+            code="LOCAL_DISPATCH_UNSUPPORTED",
+        )
+
+    def health(self, *, remote: bool = False) -> dict[str, Any]:
+        if remote or (not self.prefer_local and self.api_key):
+            return self._request("GET", "/v1/calclane/health")
+        return {"ok": True, "service": "calclane", "version": "0.3.0", "mode": "local"}
+
+    def pricing(self, *, remote: bool = False) -> dict[str, Any]:
+        if remote or (not self.prefer_local and self.api_key):
+            return self._request("GET", "/v1/calclane/pricing")
+        return {
+            "product": "calclane",
+            "currency": "credits",
+            "credits": {"calclane.evaluate": 1, "calclane.dispatch": 1},
+            "version": "0.3.0",
+        }
+
+    def capabilities(self, *, remote: bool = False) -> dict[str, Any]:
+        if remote or (not self.prefer_local and self.api_key):
+            return self._request("GET", "/v1/calclane/capabilities")
+        return {
+            "product": "calclane",
+            "version": "0.3.0",
+            "modes": ["standard", "scientific"],
+            "endpoints": [
+                "GET /v1/calclane/health",
+                "GET /v1/calclane/pricing",
+                "GET /v1/calclane/capabilities",
+                "POST /v1/calclane/evaluate",
+                "POST /v1/calclane/dispatch",
+            ],
+        }
+
+
+def create_calclane_client(
+    api_key: str | None = None,
+    base_url: str | None = None,
+    **kwargs: Any,
+) -> CalcLaneClient:
+    return CalcLaneClient(api_key=api_key, base_url=base_url, **kwargs)

talocode_calclane-0.3.0.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: talocode-calclane
+Version: 0.3.0
+Summary: CalcLane — open calculator engine for agents. Local evaluate + hosted Talocode API SDK/CLI.
+Author: Talocode
+License: MIT
+Project-URL: Homepage, https://github.com/talocode/calclane
+Project-URL: Documentation, https://docs.talocode.site
+Project-URL: Repository, https://github.com/talocode/calclane
+Project-URL: Issues, https://github.com/talocode/calclane/issues
+Project-URL: PyPI, https://pypi.org/project/talocode-calclane/
+Keywords: calculator,calclane,scientific-calculator,talocode,agents,mcp,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# CalcLane (Python)
+
+**Open calculator for agents** — local expression evaluation plus hosted Talocode API client.
+
+Part of **[Talocode](https://talocode.site)** — open tools people trust; hosted power under [docs.talocode.site](https://docs.talocode.site).
+
+| | |
+|--|--|
+| **Cloud API** | `https://api.talocode.site` → `/v1/calclane/*` |
+| **Python** | `pip install talocode-calclane` (this package) |
+| **Node** | `npm install @talocode/calclane` |
+| **Repo** | [github.com/talocode/calclane](https://github.com/talocode/calclane) |
+| **License** | MIT |
+
+---
+
+## Why CalcLane?
+
+Agents need **deterministic math** as a tool, not a free-form LLM guess:
+
+- **Structured JSON** — `ok`, `result`, `display`, `mode`, `error`
+- **Local free path** — stdlib evaluator, no network
+- **Hosted path** — same contract on Talocode Cloud (**1 credit** per evaluate)
+- **CLI** — `calclane eval "2+3*4"`
+
+---
+
+## Install
+
+```bash
+pip install talocode-calclane
+```
+
+Requires **Python 3.10+**. Stdlib only (no extra runtime deps).
+
+---
+
+## Quickstart
+
+```python
+import os
+from calclane import CalcLaneClient
+
+client = CalcLaneClient()
+
+# Local (free)
+print(client.evaluate("2 + 3 * 4"))
+print(client.evaluate("sin(90)", angle="deg"))
+print(client.evaluate("5!"))
+
+# Hosted API (1 credit) — needs TALOCODE_API_KEY
+cloud = CalcLaneClient(
+    api_key=os.environ["TALOCODE_API_KEY"],
+    prefer_local=False,
+)
+print(cloud.evaluate_remote("sqrt(144)"))
+```
+
+### Environment
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `TALOCODE_API_KEY` | — | Bearer token for hosted routes |
+| `TALOCODE_BASE_URL` | `https://api.talocode.site` | API host |
+
+---
+
+## CLI
+
+```bash
+calclane eval "2^10"
+calclane eval "sin(90)" --angle deg
+calclane health
+calclane pricing
+calclane eval "pi*2" --remote   # hosted, 1 credit
+```
+
+Or: `python -m calclane eval "..."`.
+
+---
+
+## API surface
+
+| Method | Path | Credits |
+|--------|------|---------|
+| GET | `/v1/calclane/health` | free* |
+| GET | `/v1/calclane/pricing` | free* |
+| GET | `/v1/calclane/capabilities` | free* |
+| POST | `/v1/calclane/evaluate` | **1** |
+| POST | `/v1/calclane/dispatch` | **1** |
+
+\*Valid API key required; no credit charge.
+
+Auth: `Authorization: Bearer $TALOCODE_API_KEY` or `X-Api-Key`.
+
+---
+
+## Related packages
+
+| Package | Install |
+|---------|---------|
+| This package | `pip install talocode-calclane` |
+| Node SDK / CLI | `npm i @talocode/calclane` |
+| SearchLane | `pip install talocode-searchlane` |
+| StackLane | `pip install talocode` |
+| Tera | `pip install talocode-tera` |
+
+---
+
+## Talocode ecosystem
+
+| Project | What it is |
+|---------|------------|
+| [Codra](https://github.com/talocode/codra) | Local-first agentic coding · `pip install talocode-codra` |
+| [Tera](https://github.com/talocode/tera) | AI learning companion · `pip install talocode-tera` |
+| [Stacklane](https://github.com/talocode/stacklane) | Cloud control plane · `pip install talocode` |
+| [SearchLane](https://github.com/talocode/searchlane) | Agent web search · `pip install talocode-searchlane` |
+| [DocuLane](https://github.com/talocode/doculane) | Office documents · `pip install talocode-doculane` |
+| [ContextLane](https://github.com/talocode/contextlane) | Context tooling · `pip install contextlane` |
+| [Tradia](https://github.com/talocode/tradia) | Trading agents · `pip install tradia` |
+| **[CalcLane](https://github.com/talocode/calclane)** (this package) | Open calculator · `pip install talocode-calclane` |
+
+More: [github.com/talocode](https://github.com/talocode) · [talocode.site](https://talocode.site) · [docs.talocode.site](https://docs.talocode.site)
+
+---
+
+## License
+
+MIT © Talocode

talocode_calclane-0.3.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+calclane/__init__.py,sha256=SIYjNATR9ufXlPR8i5OO_Am0XQJpImlCNoxvtjCr3Dg,272
+calclane/__main__.py,sha256=wS9uoeTWBYdb-x9No1xW2rxFILItVVkyvD_Kyudf3mc,2577
+calclane/client.py,sha256=RhmPWBlpWPftEt7_qahlaME-h968isUldsSorG2pb9g,13236
+talocode_calclane-0.3.0.dist-info/METADATA,sha256=dUdqPfhx9-aKpBV9XCdPVSWj-KHV48EPjV4AhN_cEv4,4777
+talocode_calclane-0.3.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+talocode_calclane-0.3.0.dist-info/entry_points.txt,sha256=6JEjQuPa1TkTJUNwF5igVyiAjalORUOK3BYuAXmsoYM,52
+talocode_calclane-0.3.0.dist-info/top_level.txt,sha256=68ogV2tw8XBNY9eLPWdWam9yg8R1weqGth9wICX84lY,9
+talocode_calclane-0.3.0.dist-info/RECORD,,

talocode_calclane-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

talocode_calclane-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+calclane = calclane.__main__:main

talocode_calclane-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+calclane