feat: solution for 'Экзамен: Самокорректирующийся агент'
This commit is contained in:
@@ -0,0 +1 @@
|
||||
# Package initialization for src
|
||||
+179
-49
@@ -1,67 +1,197 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Simple Self-Correcting Agent
|
||||
Self-Correcting Agent
|
||||
|
||||
This script demonstrates a minimal self‑correcting agent that
|
||||
takes a string input and attempts to correct common
|
||||
typos such as extra spaces, missing punctuation, and
|
||||
simple misspellings using a small dictionary.
|
||||
This module implements a simple self‑correcting agent that can solve
|
||||
arithmetic expressions and learn from user feedback. The agent keeps a
|
||||
knowledge base of previously solved problems and their correct answers.
|
||||
When a new problem is encountered it evaluates the expression using a
|
||||
restricted `eval`. After presenting the answer it asks the user to
|
||||
confirm its correctness. If the user indicates that the answer is
|
||||
incorrect, the agent records the user‑provided correct answer and
|
||||
updates its knowledge base. Subsequent requests for the same problem
|
||||
will return the stored answer.
|
||||
|
||||
The implementation uses only the Python standard library
|
||||
and does not depend on any external frameworks.
|
||||
Author: Artur Kuzakhmetov
|
||||
License: MIT
|
||||
"""
|
||||
|
||||
import sys
|
||||
import re
|
||||
from typing import List, Dict
|
||||
from __future__ import annotations
|
||||
|
||||
# A very small dictionary of common misspellings
|
||||
MISSPELLINGS: Dict[str, str] = {
|
||||
"teh": "the",
|
||||
"recieve": "receive",
|
||||
"adress": "address",
|
||||
"occured": "occurred",
|
||||
"seperate": "separate",
|
||||
"definately": "definitely",
|
||||
"goverment": "government",
|
||||
"untill": "until",
|
||||
"accomodate": "accommodate",
|
||||
"wich": "which",
|
||||
import ast
|
||||
import operator
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from typing import Dict, Tuple
|
||||
|
||||
# Allowed operators for safe evaluation
|
||||
_ALLOWED_OPERATORS = {
|
||||
ast.Add: operator.add,
|
||||
ast.Sub: operator.sub,
|
||||
ast.Mult: operator.mul,
|
||||
ast.Div: operator.truediv,
|
||||
ast.Pow: operator.pow,
|
||||
ast.USub: operator.neg,
|
||||
ast.UAdd: operator.pos,
|
||||
}
|
||||
|
||||
def correct_spelling(word: str) -> str:
|
||||
"""Return the corrected word if it is a known misspelling."""
|
||||
return MISSPELLINGS.get(word.lower(), word)
|
||||
|
||||
def correct_sentence(sentence: str) -> str:
|
||||
def _safe_eval(expr: str) -> float:
|
||||
"""
|
||||
Correct a sentence by:
|
||||
1. Removing leading/trailing whitespace.
|
||||
2. Collapsing multiple spaces into one.
|
||||
3. Correcting known misspellings.
|
||||
4. Ensuring the sentence ends with a period.
|
||||
Safely evaluate a simple arithmetic expression.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
expr : str
|
||||
The arithmetic expression to evaluate.
|
||||
|
||||
Returns
|
||||
-------
|
||||
float
|
||||
The numerical result of the expression.
|
||||
|
||||
Raises
|
||||
------
|
||||
ValueError
|
||||
If the expression contains unsupported syntax or operators.
|
||||
"""
|
||||
# Strip whitespace
|
||||
sentence = sentence.strip()
|
||||
# Collapse multiple spaces
|
||||
sentence = re.sub(r"\s+", " ", sentence)
|
||||
# Tokenise and correct words
|
||||
words = sentence.split(" ")
|
||||
corrected_words: List[str] = [correct_spelling(w) for w in words]
|
||||
corrected = " ".join(corrected_words)
|
||||
# Ensure ending punctuation
|
||||
if not corrected.endswith((".", "!", "?")):
|
||||
corrected += "."
|
||||
return corrected
|
||||
try:
|
||||
node = ast.parse(expr, mode="eval")
|
||||
except SyntaxError as exc:
|
||||
raise ValueError(f"Invalid expression: {expr}") from exc
|
||||
|
||||
def _eval(node: ast.AST) -> float:
|
||||
if isinstance(node, ast.Expression):
|
||||
return _eval(node.body)
|
||||
if isinstance(node, ast.Num): # Python <3.8
|
||||
return node.n
|
||||
if isinstance(node, ast.Constant): # Python 3.8+
|
||||
if isinstance(node.value, (int, float)):
|
||||
return node.value
|
||||
raise ValueError(f"Unsupported constant type: {type(node.value)}")
|
||||
if isinstance(node, ast.BinOp):
|
||||
left = _eval(node.left)
|
||||
right = _eval(node.right)
|
||||
op_type = type(node.op)
|
||||
if op_type in _ALLOWED_OPERATORS:
|
||||
return _ALLOWED_OPERATORS[op_type](left, right)
|
||||
raise ValueError(f"Unsupported operator: {op_type}")
|
||||
if isinstance(node, ast.UnaryOp):
|
||||
operand = _eval(node.operand)
|
||||
op_type = type(node.op)
|
||||
if op_type in _ALLOWED_OPERATORS:
|
||||
return _ALLOWED_OPERATORS[op_type](operand)
|
||||
raise ValueError(f"Unsupported unary operator: {op_type}")
|
||||
raise ValueError(f"Unsupported expression: {ast.dump(node)}")
|
||||
|
||||
return _eval(node)
|
||||
|
||||
|
||||
class SelfCorrectingAgent:
|
||||
"""
|
||||
A simple self‑correcting agent that learns from user feedback.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
knowledge : Dict[str, float]
|
||||
Mapping from problem string to the correct answer.
|
||||
"""
|
||||
|
||||
def __init__(self, knowledge_file: Path | None = None) -> None:
|
||||
self.knowledge: Dict[str, float] = {}
|
||||
self.knowledge_file = knowledge_file
|
||||
if knowledge_file and knowledge_file.exists():
|
||||
self._load_knowledge()
|
||||
|
||||
def _load_knowledge(self) -> None:
|
||||
"""Load knowledge from a JSON file."""
|
||||
import json
|
||||
|
||||
with self.knowledge_file.open("r", encoding="utf-8") as f:
|
||||
data = json.load(f)
|
||||
self.knowledge = {k: float(v) for k, v in data.items()}
|
||||
|
||||
def _save_knowledge(self) -> None:
|
||||
"""Persist knowledge to a JSON file."""
|
||||
if not self.knowledge_file:
|
||||
return
|
||||
import json
|
||||
|
||||
with self.knowledge_file.open("w", encoding="utf-8") as f:
|
||||
json.dump(self.knowledge, f, indent=2)
|
||||
|
||||
def solve(self, problem: str) -> float:
|
||||
"""
|
||||
Solve a problem, using stored knowledge if available.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
problem : str
|
||||
The arithmetic expression to solve.
|
||||
|
||||
Returns
|
||||
-------
|
||||
float
|
||||
The computed answer.
|
||||
"""
|
||||
if problem in self.knowledge:
|
||||
return self.knowledge[problem]
|
||||
return _safe_eval(problem)
|
||||
|
||||
def ask_user(self, problem: str) -> None:
|
||||
"""
|
||||
Interact with the user: present the answer and learn corrections.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
problem : str
|
||||
The arithmetic expression to solve.
|
||||
"""
|
||||
try:
|
||||
answer = self.solve(problem)
|
||||
except ValueError as exc:
|
||||
print(f"Error: {exc}")
|
||||
return
|
||||
|
||||
print(f"Answer: {answer}")
|
||||
while True:
|
||||
resp = input("Is this correct? (y/n): ").strip().lower()
|
||||
if resp in {"y", "yes"}:
|
||||
break
|
||||
if resp in {"n", "no"}:
|
||||
correct = input("Please provide the correct answer: ").strip()
|
||||
try:
|
||||
correct_val = float(correct)
|
||||
except ValueError:
|
||||
print("Invalid number. Try again.")
|
||||
continue
|
||||
self.knowledge[problem] = correct_val
|
||||
print("Knowledge updated.")
|
||||
break
|
||||
print("Please answer 'y' or 'n'.")
|
||||
|
||||
def run(self) -> None:
|
||||
"""
|
||||
Run an interactive loop until the user exits.
|
||||
"""
|
||||
print("Self‑Correcting Agent")
|
||||
print("Type 'exit' to quit.")
|
||||
while True:
|
||||
problem = input("Enter problem: ").strip()
|
||||
if problem.lower() in {"exit", "quit"}:
|
||||
print("Goodbye!")
|
||||
self._save_knowledge()
|
||||
break
|
||||
if not problem:
|
||||
continue
|
||||
self.ask_user(problem)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
if len(sys.argv) < 2:
|
||||
print("Usage: python -m src.index \"<sentence>\"")
|
||||
sys.exit(1)
|
||||
"""Entry point for the command‑line interface."""
|
||||
agent = SelfCorrectingAgent(knowledge_file=Path("knowledge.json"))
|
||||
agent.run()
|
||||
|
||||
input_sentence = " ".join(sys.argv[1:])
|
||||
corrected = correct_sentence(input_sentence)
|
||||
print(corrected)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user