| import ast
|
| import datetime as dt
|
| import math
|
| import re
|
| from functools import lru_cache
|
| from typing import Dict, List
|
|
|
| from duckduckgo_search import DDGS
|
|
|
|
|
| _ALLOWED_MATH_FUNCS = {
|
| "sqrt": math.sqrt,
|
| "sin": math.sin,
|
| "cos": math.cos,
|
| "tan": math.tan,
|
| "log": math.log,
|
| "log10": math.log10,
|
| "exp": math.exp,
|
| "fabs": math.fabs,
|
| "ceil": math.ceil,
|
| "floor": math.floor,
|
| "pow": math.pow,
|
| }
|
|
|
| _ALLOWED_CONSTANTS = {
|
| "pi": math.pi,
|
| "e": math.e,
|
| }
|
|
|
|
|
| class UnsafeExpressionError(ValueError):
|
| pass
|
|
|
|
|
| def _safe_eval(node: ast.AST) -> float:
|
| if isinstance(node, ast.Expression):
|
| return _safe_eval(node.body)
|
|
|
| if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
|
| return float(node.value)
|
|
|
| if isinstance(node, ast.BinOp):
|
| left = _safe_eval(node.left)
|
| right = _safe_eval(node.right)
|
|
|
| if isinstance(node.op, ast.Add):
|
| return left + right
|
| if isinstance(node.op, ast.Sub):
|
| return left - right
|
| if isinstance(node.op, ast.Mult):
|
| return left * right
|
| if isinstance(node.op, ast.Div):
|
| return left / right
|
| if isinstance(node.op, ast.FloorDiv):
|
| return left // right
|
| if isinstance(node.op, ast.Mod):
|
| return left % right
|
| if isinstance(node.op, ast.Pow):
|
| return left ** right
|
| raise UnsafeExpressionError("Unsupported binary operator.")
|
|
|
| if isinstance(node, ast.UnaryOp):
|
| value = _safe_eval(node.operand)
|
| if isinstance(node.op, ast.UAdd):
|
| return +value
|
| if isinstance(node.op, ast.USub):
|
| return -value
|
| raise UnsafeExpressionError("Unsupported unary operator.")
|
|
|
| if isinstance(node, ast.Name):
|
| if node.id in _ALLOWED_CONSTANTS:
|
| return _ALLOWED_CONSTANTS[node.id]
|
| raise UnsafeExpressionError(f"Unknown identifier: {node.id}")
|
|
|
| if isinstance(node, ast.Call):
|
| if not isinstance(node.func, ast.Name):
|
| raise UnsafeExpressionError("Only direct function calls are allowed.")
|
|
|
| func_name = node.func.id
|
| func = _ALLOWED_MATH_FUNCS.get(func_name)
|
| if func is None:
|
| raise UnsafeExpressionError(f"Unsupported function: {func_name}")
|
|
|
| args = [_safe_eval(arg) for arg in node.args]
|
| return float(func(*args))
|
|
|
| raise UnsafeExpressionError("Unsupported expression.")
|
|
|
|
|
| def calculator_tool(expression: str) -> str:
|
| try:
|
| parsed = ast.parse(expression, mode="eval")
|
| value = _safe_eval(parsed)
|
| if value.is_integer():
|
| return str(int(value))
|
| return str(round(value, 10))
|
| except Exception as exc:
|
| return f"Calculation error: {exc}"
|
|
|
|
|
| @lru_cache(maxsize=128)
|
| def web_search_tool(query: str, max_results: int = 5) -> str:
|
| try:
|
| rows: List[Dict] = []
|
| with DDGS() as ddgs:
|
| for item in ddgs.text(query, max_results=max_results):
|
| rows.append(item)
|
|
|
| if not rows:
|
| return "No web results found."
|
|
|
| summary_lines = []
|
| for idx, row in enumerate(rows, start=1):
|
| title = row.get("title", "Untitled")
|
| snippet = row.get("body", "").strip()
|
| href = row.get("href", "")
|
| snippet = snippet[:220] + ("..." if len(snippet) > 220 else "")
|
| summary_lines.append(f"{idx}. {title} | {snippet} | Source: {href}")
|
|
|
| return "\n".join(summary_lines)
|
| except Exception as exc:
|
| return f"Web search unavailable: {exc}"
|
|
|
|
|
| def datetime_tool() -> str:
|
| now = dt.datetime.now().astimezone()
|
| return (
|
| f"Current date: {now.strftime('%Y-%m-%d')}\n"
|
| f"Current time: {now.strftime('%H:%M:%S %Z')}"
|
| )
|
|
|
|
|
| def text_stats_tool(text: str) -> str:
|
| cleaned = text.strip()
|
| if not cleaned:
|
| return "Words: 0\nCharacters: 0\nSentences: 0"
|
|
|
| words = len(re.findall(r"\b\w+\b", cleaned))
|
| chars = len(cleaned)
|
| sentences = len([s for s in re.split(r"[.!?]+", cleaned) if s.strip()])
|
| return f"Words: {words}\nCharacters: {chars}\nSentences: {sentences}"
|
|
|
