Merge pull request #112 from QWED-AI/rahul/unused-import-cleanup-3

rahuldass19 · web-flow · commit 13af4ff35449 · 2026-04-01T13:25:51.000+05:30
Clean up unused imports and broad except handlers
diff --git a/action_entrypoint.py b/action_entrypoint.py
@@ -10,7 +10,6 @@
 import os
 import sys
 import json
-import glob
 from pathlib import Path
 
 try:
diff --git a/qwed/guards/attestation_guard.py b/qwed/guards/attestation_guard.py
@@ -1,6 +1,5 @@
 import jwt
 import time
-import json
 import hashlib
 import os
 from typing import Dict, Any, Optional
@@ -13,13 +12,17 @@ class AttestationGuard:
     def __init__(self, secret_key: str = None, allow_insecure: bool = False):
         self.secret = secret_key or os.environ.get("QWED_ATTESTATION_SECRET")
         if not self.secret:
-            if allow_insecure or os.environ.get("QWED_DEV_MODE") == "1":
-                # deepcode ignore HardcodedSecret: Dev-mode fallback, only active with explicit opt-in
-                self.secret = "dev-secret-insecure"
-            else:
-                raise ValueError("QWED_ATTESTATION_SECRET required. Set allow_insecure=True for dev mode.")
+            raise ValueError(
+                "QWED_ATTESTATION_SECRET required. Refusing insecure fallback secret."
+            )
 
-    def sign_verification(self, input_query: str, guard_result: Dict[str, Any], engine: str = "QWED-Deterministic-v1") -> str:
+    def sign_verification(
+        self,
+        input_query: str,
+        guard_result: Dict[str, Any],
+        engine: str = "QWED-Deterministic-v1",
+        timestamp: Optional[float] = None,
+    ) -> str:
         """
         Creates a JWT attesting that a specific verification occurred.
         Source: QWED Features list.
@@ -28,7 +31,7 @@ def sign_verification(self, input_query: str, guard_result: Dict[str, Any], engi
         query_hash = hashlib.sha256(input_query.encode('utf-8')).hexdigest()
         
         payload = {
-            "timestamp": time.time(),
+            "timestamp": time.time() if timestamp is None else timestamp,
             "query_hash": query_hash,
             "verification_result": guard_result.get("verified", False),
             "engine": engine,
diff --git a/qwed_sdk/cache.py b/qwed_sdk/cache.py
@@ -257,7 +257,7 @@ def print_stats(self):
         
         try:
             from qwed_sdk.qwed_local import QWED, HAS_COLOR
-        except:
+        except (ImportError, AttributeError):
             HAS_COLOR = False
             class QWED:
                 BRAND = INFO = SUCCESS = VALUE = RESET = ""
diff --git a/scripts/benchmark_hard.py b/scripts/benchmark_hard.py
@@ -138,7 +138,7 @@ def verify_answer(claude_answer: str, expected, expression: str) -> tuple:
             return expected, is_correct
         
         return expected, False
-    except:
+    except Exception:
         return expected, False
 
 def run_hard_benchmark():
diff --git a/scripts/benchmark_math.py b/scripts/benchmark_math.py
@@ -96,7 +96,7 @@ def call_claude(query: str) -> str:
         if numbers:
             return float(numbers[0])
         return None
-    except:
+    except Exception:
         return None
 
 def verify_with_qwed(query: str, llm_answer: float, expected: float) -> Dict:
diff --git a/scripts/find_azure.py b/scripts/find_azure.py
@@ -12,5 +12,5 @@
     for name, obj in inspect.getmembers(resources):
         if "Azure" in name or "Foundry" in name:
             print(f"Found in resources: {name}")
-except:
-    pass
+except ImportError:
+    print("anthropic.resources not available; skipping nested resource scan")
diff --git a/scripts/stress_test.py b/scripts/stress_test.py
@@ -40,7 +40,7 @@ def send_request(query_id, query):
         try:
             data = response.json()
             result_status = data.get("status", "UNKNOWN")
-        except:
+        except Exception:
             result_status = "PARSE_ERROR"
             
         return {
diff --git a/src/qwed_new/api/main.py b/src/qwed_new/api/main.py
@@ -430,7 +430,7 @@ async def verify_math(
                             "simplified": str(simplified),
                             "original": str(parsed)
                         }
-                    except:
+                    except Exception:
                         # Symbolic expression
                         result = {
                             "is_valid": True,
diff --git a/src/qwed_new/auth/audit_routes.py b/src/qwed_new/auth/audit_routes.py
@@ -2,7 +2,7 @@
 Audit log routes for QWED Enterprise Portal.
 """
 from fastapi import APIRouter, Depends, Query, HTTPException
-from typing import Optional, List
+from typing import Optional
 import csv
 import io
 from datetime import datetime, timedelta
diff --git a/src/qwed_new/core/ablation_tracker.py b/src/qwed_new/core/ablation_tracker.py
@@ -19,7 +19,7 @@
     markdown = tracker.export_markdown()
 """
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Dict, List, Any, Optional
 from datetime import datetime
 from enum import Enum
diff --git a/src/qwed_new/core/agent_models.py b/src/qwed_new/core/agent_models.py
@@ -8,7 +8,7 @@
 - Tool call tracking
 """
 
-from typing import Optional, List
+from typing import Optional
 from sqlmodel import Field, SQLModel, JSON, Column
 from datetime import datetime
 from enum import Enum
diff --git a/src/qwed_new/core/agent_registry.py b/src/qwed_new/core/agent_registry.py
@@ -11,10 +11,10 @@
 import secrets
 from typing import List, Optional, Tuple
 from sqlmodel import Session, select
-from datetime import datetime, timedelta
+from datetime import datetime
 
 from qwed_new.core.agent_models import (
-    Agent, AgentPermission, AgentActivity, ToolCall,
+    Agent, AgentPermission, AgentActivity,
     AgentType, AgentStatus
 )
 
diff --git a/src/qwed_new/core/agent_service.py b/src/qwed_new/core/agent_service.py
@@ -5,14 +5,12 @@
 Provides registration, verification, budget management, and audit logging.
 """
 
-import hashlib
 import time
 import uuid
 from dataclasses import dataclass, field
-from datetime import datetime, timedelta
+from datetime import datetime
 from typing import Optional, Dict, Any, List, Set
 from enum import Enum
-import json
 
 
 class AgentType(Enum):
diff --git a/src/qwed_new/core/alerting.py b/src/qwed_new/core/alerting.py
@@ -15,7 +15,7 @@
 import smtplib
 from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional
 from datetime import datetime, timedelta
 from collections import defaultdict
 
diff --git a/src/qwed_new/core/attestation.py b/src/qwed_new/core/attestation.py
@@ -10,8 +10,7 @@
 import base64
 import time
 import uuid
-from dataclasses import dataclass, field
-from datetime import datetime, timedelta
+from dataclasses import dataclass
 from typing import Optional, Dict, Any, List, Tuple
 from enum import Enum
 
diff --git a/src/qwed_new/core/consensus_verifier.py b/src/qwed_new/core/consensus_verifier.py
@@ -12,6 +12,7 @@
 from typing import List, Dict, Any, Optional, Tuple, Callable
 from dataclasses import dataclass, field
 from enum import Enum
+from decimal import Decimal
 import time
 import asyncio
 from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -745,20 +746,27 @@ def _calculate_consensus(self, results: List[EngineResult]) -> Dict[str, Any]:
     # Helper Methods
     # =========================================================================
     
-    def _parse_math_query(self, query: str) -> Tuple[str, float]:
+    def _parse_math_query(self, query: str) -> Tuple[str, Decimal]:
         """Parse query into expression and expected value."""
         try:
             from qwed_new.core.translator import TranslationLayer
             translator = TranslationLayer()
             task = translator.translate(query)
-            return task.expression, task.expected_value or 0.0
-        except:
+        except ImportError:
             # Fallback: extract simple expression
             import re
             nums = re.findall(r"\d+", query)
             if len(nums) >= 2:
-                return f"{nums[0]} + {nums[1]}", float(nums[0]) + float(nums[1])
-            return "0", 0.0
+                exact_sum = Decimal(nums[0]) + Decimal(nums[1])
+                return f"{nums[0]} + {nums[1]}", exact_sum
+            return "0", Decimal("0")
+
+        expected_value = task.expected_value
+        if expected_value is None:
+            return task.expression, Decimal("0")
+        if isinstance(expected_value, Decimal):
+            return task.expression, expected_value
+        return task.expression, Decimal(str(expected_value))
     
     def _generate_verification_code(self, query: str) -> str:
         """Generate Python code for verification."""
@@ -767,17 +775,17 @@ def _generate_verification_code(self, query: str) -> str:
             translator = TranslationLayer()
             task = translator.translate(query)
             return f"print({task.expression})"
-        except:
-            return "print('Unable to generate code')"
+        except Exception as e:
+            raise ValueError(f"Verification code generation failed: {e}") from e
     
     def _model_as_logic(self, query: str) -> Tuple[Dict, List]:
         """Model query as logic constraints."""
         try:
             from qwed_new.core.translator import TranslationLayer
             translator = TranslationLayer()
             return translator.translate_logic(query)
-        except:
-            return {}, []
+        except Exception as e:
+            raise ValueError(f"Logic translation failed: {e}") from e
     
     # =========================================================================
     # Health Monitoring
diff --git a/src/qwed_new/core/logic_verifier.py b/src/qwed_new/core/logic_verifier.py
@@ -550,7 +550,8 @@ def _explain_unsat(self, solver: Solver, constraints: List[str]) -> str:
             core = solver.unsat_core()
             if core:
                 return f"Conflicting constraints: {[str(c) for c in core]}"
-        except:
+        except Exception:
+            # Unsat-core extraction is best-effort; fall back to a generic explanation.
             pass
         
         return "Constraints are logically inconsistent"
diff --git a/src/qwed_new/core/reasoning_verifier.py b/src/qwed_new/core/reasoning_verifier.py
@@ -12,12 +12,18 @@
 6. Confidence scoring
 """
 
+import ast
+from decimal import Decimal, localcontext
+import logging
+import operator
 import re
 import hashlib
 from typing import Dict, Any, List, Optional, Callable
 from dataclasses import dataclass, field
 import time
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class ReasoningValidation:
@@ -505,13 +511,47 @@ def _formulas_equivalent(self, formula1: str, formula2: str) -> bool:
         try:
             # Only evaluate if they look safe
             if re.match(r'^[\d\+\-\*/\.\(\)]+$', f1) and re.match(r'^[\d\+\-\*/\.\(\)]+$', f2):
-                v1 = eval(f1)
-                v2 = eval(f2)
-                return abs(v1 - v2) < 0.0001
-        except:
-            pass
+                v1 = self._safe_arithmetic_eval(f1)
+                v2 = self._safe_arithmetic_eval(f2)
+                return abs(v1 - v2) < Decimal("0.0001")
+        except Exception as e:
+            # Best-effort numeric fallback; treat evaluation failures as non-equivalent.
+            logger.debug("Safe arithmetic fallback failed for formulas %s vs %s: %s", f1, f2, e)
         
         return False
+
+    def _safe_arithmetic_eval(self, expr: str) -> Decimal:
+        """Safely evaluate a simple arithmetic expression for formula fallback checks."""
+        allowed_binops = {
+            ast.Add: operator.add,
+            ast.Sub: operator.sub,
+            ast.Mult: operator.mul,
+            ast.Div: lambda left, right: left / right,
+            ast.Pow: operator.pow,
+        }
+        allowed_unary = {
+            ast.UAdd: operator.pos,
+            ast.USub: operator.neg,
+        }
+
+        def _eval(node):
+            if isinstance(node, ast.Expression):
+                return _eval(node.body)
+            if isinstance(node, ast.Constant) and type(node.value) in (int, float):
+                literal = ast.get_source_segment(expr, node)
+                if literal is not None:
+                    return Decimal(literal)
+                return Decimal(str(node.value))
+            if isinstance(node, ast.BinOp) and type(node.op) in allowed_binops:
+                return allowed_binops[type(node.op)](_eval(node.left), _eval(node.right))
+            if isinstance(node, ast.UnaryOp) and type(node.op) in allowed_unary:
+                return allowed_unary[type(node.op)](_eval(node.operand))
+            raise ValueError("Unsafe arithmetic expression")
+
+        tree = ast.parse(expr, mode="eval")
+        with localcontext() as ctx:
+            ctx.prec = 50
+            return _eval(tree)
     
     # =========================================================================
     # Confidence Calculation
diff --git a/src/qwed_new/core/symbolic_verifier.py b/src/qwed_new/core/symbolic_verifier.py
@@ -620,7 +620,16 @@ def verify_bounded(
             }
         
         # Transform code to add bounds
-        bounded_code = self._add_bounds_to_code(code, loop_bound, recursion_depth)
+        try:
+            bounded_code = self._add_bounds_to_code(code, loop_bound, recursion_depth)
+        except ValueError as e:
+            return {
+                "is_verified": False,
+                "status": "bounds_transform_error",
+                "message": str(e),
+                "bounded": False,
+                "issues": [{"type": "error", "description": str(e)}],
+            }
         
         # Run verification on bounded code
         result = self.verify_code(bounded_code)
@@ -694,8 +703,8 @@ def visit_FunctionDef(self, node):
         
         try:
             return ast.unparse(new_tree)
-        except:
-            return code  # Return original if transform fails
+        except Exception as e:
+            raise ValueError("Failed to apply bounded-model transform") from e
     
     def get_verification_budget(
         self, 
diff --git a/src/qwed_new/core/verifier.py b/src/qwed_new/core/verifier.py
diff --git a/src/qwed_new/providers/anthropic.py b/src/qwed_new/providers/anthropic.py
diff --git a/src/qwed_new/providers/auto_shift.py b/src/qwed_new/providers/auto_shift.py
diff --git a/src/qwed_new/providers/azure_openai.py b/src/qwed_new/providers/azure_openai.py
diff --git a/tests/test_pr112_regressions.py b/tests/test_pr112_regressions.py
diff --git a/tests/test_qwed_local_coverage.py b/tests/test_qwed_local_coverage.py

Original file line number	Diff line number	Diff line change
`@@ -430,7 +430,7 @@ async def verify_math(`
`430`	`430`	`"simplified": str(simplified),`
`431`	`431`	`"original": str(parsed)`
`432`	`432`	`}`
`433`		`- except:`
	`433`	`+ except Exception:`
`434`	`434`	`# Symbolic expression`
`435`	`435`	`result = {`
`436`	`436`	`"is_valid": True,`