aegisstate 0.1.0__py3-none-any.whl

aegisstate/__init__.py

@@ -0,0 +1,4 @@
+from .engine import AegisState
+from .executor import ProtectedExecutor
+
+__all__ = ["AegisState", "ProtectedExecutor"]

aegisstate/agent.py

@@ -0,0 +1,20 @@
+class Agent:
+    def __init__(self, state):
+        self.state = state
+
+    def execute(self, action_name):
+        """Execute an action only if AegisState allows it."""
+
+        decision = self.state.validate(action_name)
+
+        if not decision["valid"]:
+            print(f"BLOCKED: {action_name}")
+            print(f"Reason: {decision['reason']}")
+
+            return False
+
+        print(f"ALLOWED: {action_name}")
+        print(f"Reason: {decision['reason']}")
+        print("Action executed (simulation only).")
+
+        return True

aegisstate/benchmark.py

@@ -0,0 +1,70 @@
+
+from time import perf_counter
+
+from aegisstate.engine import AegisState
+
+
+def build_chain(size=100):
+    state = AegisState()
+
+    for i in range(size):
+        state.add_item(f"decision_{i}")
+
+    for i in range(1, size):
+        state.add_dependency(
+            f"decision_{i}",
+            f"decision_{i - 1}",
+        )
+
+    # Record decisions from the root to the final node.
+    for i in range(size):
+        state.commit_decision(
+            f"decision_{i}",
+            {"value": i},
+        )
+
+    return state
+
+
+def main():
+    size = 100
+    repetitions = 100
+
+    state = build_chain(size)
+    final_decision = f"decision_{size - 1}"
+
+    # Measure validation before any evidence changes.
+    start = perf_counter()
+
+    for _ in range(repetitions):
+        result = state.validate(final_decision)
+
+        if not result["valid"]:
+            raise RuntimeError("Expected a valid decision")
+
+    validation_time = (
+        perf_counter() - start
+    ) / repetitions
+
+    # Build a fresh graph for the invalidation measurement.
+    state = build_chain(size)
+
+    start = perf_counter()
+    state.set_version("decision_0", 2)
+    invalidation_time = perf_counter() - start
+
+    print("\n=== AEGISSTATE DAY 8 BENCHMARK ===")
+    print(f"Dependency chain size: {size}")
+    print(f"Validation repetitions: {repetitions}")
+    print(
+        f"Average validation time: "
+        f"{validation_time * 1000:.3f} ms"
+    )
+    print(
+        f"Root-change invalidation time: "
+        f"{invalidation_time * 1000:.3f} ms"
+    )
+
+
+if __name__ == "__main__":
+    main()

aegisstate/demo.py

@@ -0,0 +1,95 @@
+
+from aegisstate.engine import AegisState
+from aegisstate.executor import ProtectedExecutor
+
+
+def main():
+    state = AegisState()
+    executor = ProtectedExecutor(state)
+
+    state.add_item("transaction")
+    state.add_item("risk_assessment")
+    state.add_item("approval")
+    state.add_item("agent_action")
+    state.add_item("inventory_report")
+    state.add_item("inventory_data")
+
+    state.add_dependency("risk_assessment", "transaction")
+    state.add_dependency("approval", "risk_assessment")
+    state.add_dependency("agent_action", "approval")
+
+    state.add_dependency("inventory_report", "inventory_data")
+
+    state.commit_decision(
+        "risk_assessment",
+        {"risk_score": 20},
+    )
+    state.commit_decision(
+        "approval",
+        {"approved": True},
+    )
+    state.commit_decision(
+        "agent_action",
+        {"action": "execute_transaction"},
+    )
+    state.commit_decision(
+        "inventory_report",
+        {"items_available": 120},
+    )
+
+    print("\n1. Initial decisions recorded.")
+
+    result = executor.execute(
+        "execute_transaction",
+        "agent_action",
+        lambda: "Transaction executed",
+    )
+    print("Initial execution:", result)
+
+    state.set_version("transaction", 2)
+
+    print("\n2. Transaction evidence changed.")
+
+    print(
+        "Risk assessment:",
+        state.validate("risk_assessment"),
+    )
+    print("Approval:", state.validate("approval"))
+    print("Agent action:", state.validate("agent_action"))
+    print(
+        "Inventory report:",
+        state.validate("inventory_report"),
+    )
+
+    blocked = executor.execute(
+        "execute_transaction",
+        "agent_action",
+        lambda: "Transaction executed",
+    )
+    print("\n3. Attempt using stale approval:", blocked)
+
+    state.commit_decision(
+        "risk_assessment",
+        {"risk_score": 35},
+    )
+    state.commit_decision(
+        "approval",
+        {"approved": True},
+    )
+    state.commit_decision(
+        "agent_action",
+        {"action": "execute_transaction"},
+    )
+
+    print("\n4. Decisions recalculated.")
+
+    recovered = executor.execute(
+        "execute_transaction",
+        "agent_action",
+        lambda: "Transaction executed after revalidation",
+    )
+    print("Execution after recovery:", recovered)
+
+
+if __name__ == "__main__":
+    main()

aegisstate/demo2.py

@@ -0,0 +1,164 @@
+
+import math
+
+from aegisstate.engine import AegisState
+from aegisstate.executor import ProtectedExecutor
+
+
+def read_transaction(label):
+    """Collect transaction evidence at runtime."""
+    print(f"\n--- {label} ---")
+
+    while True:
+        try:
+            amount = float(input("Transaction amount: "))
+
+            # float() accepts "nan" and "inf". NaN is False for every
+            # comparison, so it would skip all risk thresholds and receive
+            # the lowest risk score (auto-approval).
+            if not math.isfinite(amount):
+                print("Enter a finite number.")
+                continue
+
+            if amount < 0:
+                print("Amount cannot be negative.")
+                continue
+
+            break
+        except ValueError:
+            print("Enter a valid number.")
+
+    while True:
+        status = input(
+            "Transaction status (pending/completed/cancelled): "
+        ).strip().lower()
+
+        if status in {"pending", "completed", "cancelled"}:
+            break
+
+        print("Enter pending, completed, or cancelled.")
+
+    return {
+        "amount": amount,
+        "status": status,
+    }
+
+
+def calculate_risk(transaction):
+    """Calculate a demonstration risk score from the evidence."""
+    amount = transaction["amount"]
+    status = transaction["status"]
+
+    if status != "pending":
+        return 100
+    if amount > 100_000:
+        return 80
+    if amount > 50_000:
+        return 60
+
+    return 20
+
+
+def process_decisions(state, transaction):
+    """Recalculate decisions using the current transaction evidence."""
+    risk_score = calculate_risk(transaction)
+
+    approval = (
+        risk_score < 50
+        and transaction["status"] == "pending"
+    )
+
+    state.commit_decision(
+        "risk_assessment",
+        {
+            "risk_score": risk_score,
+            "based_on": transaction.copy(),
+        },
+    )
+
+    state.commit_decision(
+        "approval",
+        {
+            "approved": approval,
+            "risk_score": risk_score,
+        },
+    )
+
+    print(f"Calculated risk score: {risk_score}")
+    print(f"Approval decision: {approval}")
+
+    return approval
+
+
+def main():
+    state = AegisState()
+    executor = ProtectedExecutor(state)
+
+    state.add_item("transaction", version=1)
+    state.add_item("risk_assessment")
+    state.add_item("approval")
+    state.add_item("agent_action")
+
+    state.add_dependency("risk_assessment", "transaction")
+    state.add_dependency("approval", "risk_assessment")
+    state.add_dependency("agent_action", "approval")
+
+    # First transaction input.
+    first_transaction = read_transaction("FIRST TRANSACTION")
+
+    print("\n--- FIRST DECISION ---")
+    first_approved = process_decisions(state, first_transaction)
+
+    if first_approved:
+        state.commit_decision(
+            "agent_action",
+            {"action": "process_transaction"},
+        )
+
+    first_result = executor.execute(
+        "process_transaction",
+        "agent_action",
+        lambda: "Transaction action executed",
+    )
+    print("Execution result:", first_result)
+
+    # Read the evidence again to detect changes.
+    second_transaction = read_transaction("UPDATED TRANSACTION")
+
+    if second_transaction == first_transaction:
+        print("\nEvidence has not changed.")
+        print("No new version is required.")
+        return
+
+    print("\nEvidence changed! Updating transaction version...")
+    state.set_version("transaction", 2)
+
+    print("\n--- STALE DECISION CHECK ---")
+    print(state.validate("agent_action"))
+
+    print("\n--- RECOMPUTING DECISIONS ---")
+    second_approved = process_decisions(state, second_transaction)
+
+    if second_approved:
+        # Commit a fresh action decision based on fresh approval.
+        state.commit_decision(
+            "agent_action",
+            {"action": "process_updated_transaction"},
+        )
+    else:
+        print("No new action decision will be committed.")
+
+    print("\n--- FINAL EXECUTION CHECK ---")
+    final_result = executor.execute(
+        "process_transaction",
+        "agent_action",
+        lambda: "Transaction action executed",
+    )
+    print("Execution result:", final_result)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (EOFError, KeyboardInterrupt):
+        print("\nInput ended; exiting.")