a3-python 0.1.19__tar.gz → 0.1.21__tar.gz

{a3_python-0.1.19 → a3_python-0.1.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: a3-python
-Version: 0.1.19
+Version: 0.1.21
 Summary: Catch real Python bugs before production — 99%+ accuracy, Z3 symbolic execution, LLM-powered false-positive filtering, zero-config GitHub CI
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{a3_python-0.1.19 → a3_python-0.1.21}/a3_python/analyzer.py

@@ -2135,13 +2135,13 @@ class Analyzer:
                     var_names = list(loop.modified_variables)
                     
                     # Generate sample positive/negative examples
-                    positive = set()
-                    negative = set()
+                    positive = []
+                    negative = []
                     implications = []
                     
                     # Add simple examples (heuristic)
-                    positive.add({v: 0 for v in var_names})
-                    positive.add({v: 1 for v in var_names})
+                    positive.append({v: 0 for v in var_names})
+                    positive.append({v: 1 for v in var_names})
                     
                     # Try ICE learning
                     result = learn_ice_invariant(
@@ -2912,13 +2912,19 @@ class Analyzer:
             # Compile the module
             module_code = compile(source, str(filepath), 'exec')
             
-            # Search for the function in the module's constants
-            for const in module_code.co_consts:
-                if isinstance(const, types.CodeType):
-                    if const.co_name == function_name:
-                        return const
+            # Search recursively for the function (handles class methods too)
+            def _find_code(code_obj, name):
+                for const in code_obj.co_consts:
+                    if isinstance(const, types.CodeType):
+                        if const.co_name == name:
+                            return const
+                        # Recurse into nested code objects (e.g., class bodies)
+                        result = _find_code(const, name)
+                        if result is not None:
+                            return result
+                return None
             
-            return None
+            return _find_code(module_code, function_name)
         except Exception as e:
             if self.verbose:
                 print(f"  Error extracting function {function_name}: {e}")
@@ -2974,8 +2980,9 @@ class Analyzer:
                     if isinstance(const, types.CodeType):
                         name = const.co_name
                         
-                        # Skip module-level code, lambdas, and comprehensions
-                        if name in ('<module>', '<lambda>', '<listcomp>', '<dictcomp>', '<setcomp>', '<genexpr>'):
+                        # Skip module-level code, lambdas, comprehensions, and
+                        # compiler-generated annotation functions (Python 3.14+ PEP 649)
+                        if name in ('<module>', '<lambda>', '<listcomp>', '<dictcomp>', '<setcomp>', '<genexpr>', '__annotate__'):
                             continue
                             
                         # Check if this is a class definition
@@ -3050,8 +3057,9 @@ class Analyzer:
             all_functions = {}
             for const in module_code.co_consts:
                 if isinstance(const, types.CodeType):
-                    # Skip module-level code and lambdas
-                    if const.co_name == '<module>' or const.co_name == '<lambda>':
+                    # Skip module-level code, lambdas, and compiler-generated
+                    # annotation functions (Python 3.14+ PEP 649)
+                    if const.co_name in ('<module>', '<lambda>', '__annotate__'):
                         continue
                     # Skip class definitions (they have __classdict__ in cellvars)
                     if '__classdict__' in const.co_cellvars:
@@ -3061,7 +3069,14 @@ class Analyzer:
             # Check if there's any executable code at module level beyond function definitions
             import dis
             has_executable_code = False
-            function_def_opcodes = {'MAKE_FUNCTION', 'STORE_NAME', 'STORE_GLOBAL', 'LOAD_CONST'}
+            # Include annotation bookkeeping opcodes (Python 3.14 PEP 649) so that
+            # annotation-only modules are still correctly classified as library files
+            function_def_opcodes = {
+                'MAKE_FUNCTION', 'STORE_NAME', 'STORE_GLOBAL', 'LOAD_CONST',
+                'MAKE_CELL', 'BUILD_SET', 'SET_ADD', 'POP_TOP',
+                'SET_FUNCTION_ATTRIBUTE', 'LOAD_SMALL_INT', 'LOAD_NAME',
+                'PUSH_NULL', 'SETUP_ANNOTATIONS',
+            }
             
             for instr in dis.get_instructions(module_code):
                 # Skip RESUME and function definition opcodes

{a3_python-0.1.19 → a3_python-0.1.21}/a3_python/ci/templates/a3-pr-scan.yml

@@ -25,6 +25,7 @@ permissions:
   contents: read
   security-events: write   # needed for SARIF upload
   pull-requests: write      # needed for PR comments (optional)
+  models: read              # needed for GitHub Models (agentic triage)
 
 jobs:
   a3-scan:

{a3_python-0.1.19 → a3_python-0.1.21}/a3_python/ci/templates/a3-scheduled-scan.yml

@@ -20,6 +20,7 @@ permissions:
   contents: write            # needed to update baseline
   security-events: write     # needed for SARIF upload
   issues: write              # needed for auto-issue creation
+  models: read               # needed for GitHub Models (agentic triage)
 
 jobs:
   a3-full-scan:

{a3_python-0.1.19 → a3_python-0.1.21}/a3_python/semantics/symbolic_vm.py

@@ -511,6 +511,12 @@ class SymbolicVM:
         self.verbose = verbose
         self.paths: List[SymbolicPath] = []
         self._instruction_cache: Dict[int, Dict[int, dis.Instruction]] = {}
+        self._obj_id_counter = 0
+
+    def fresh_obj_id(self) -> int:
+        """Return a fresh unique object ID for heap allocation."""
+        self._obj_id_counter += 1
+        return self._obj_id_counter
 
     def _solver_maybe_sat(self) -> bool:
         """
@@ -772,7 +778,16 @@ class SymbolicVM:
                     print(f"  Top of stack: {frame.operand_stack[-3:]}")
             
             # Increment per-instruction step counter (k-step reachability index).
-            state.step_count += 1
+            # Skip counting annotation bookkeeping instructions (Python 3.14 PEP 649)
+            # so that type annotations don't consume the exploration budget.
+            _annotation_bookkeeping = (
+                instruction.opname == 'SETUP_ANNOTATIONS'
+                or (instruction.opname == 'STORE_NAME' and instruction.argval in ('__annotate__', '__annotations__', '__conditional_annotations__'))
+                or (instruction.opname == 'LOAD_NAME' and instruction.argval == '__conditional_annotations__')
+                or (instruction.opname == 'SET_ADD' and hasattr(frame, 'locals') and '__conditional_annotations__' in getattr(frame, 'locals', {}))
+            )
+            if not _annotation_bookkeeping:
+                state.step_count += 1
 
             self._execute_instruction(state, frame, instruction)
             path.trace.append(f"{instruction.offset:4d}: {instruction.opname} {instruction.argrepr}")
@@ -1201,13 +1216,13 @@ class SymbolicVM:
         """Compute the next instruction offset."""
         code = frame.code
         
-        # Cache instructions to avoid repeated dis.get_instructions calls
-        # This is a major performance optimization for large functions
+        # Use a SEPARATE cache from _instruction_cache (which stores offset→Instruction).
+        # This cache stores offset→next_offset (int→int).
         cache_key = id(code)
-        if not hasattr(self, '_instruction_cache'):
-            self._instruction_cache = {}
+        if not hasattr(self, '_next_offset_cache'):
+            self._next_offset_cache = {}
         
-        if cache_key not in self._instruction_cache:
+        if cache_key not in self._next_offset_cache:
             instructions = list(dis.get_instructions(code))
             # Build offset -> next_offset map for O(1) lookup
             offset_map = {}
@@ -1216,9 +1231,9 @@ class SymbolicVM:
                     offset_map[inst.offset] = instructions[i + 1].offset
                 else:
                     offset_map[inst.offset] = len(code.co_code)
-            self._instruction_cache[cache_key] = offset_map
+            self._next_offset_cache[cache_key] = offset_map
         
-        offset_map = self._instruction_cache[cache_key]
+        offset_map = self._next_offset_cache[cache_key]
         return offset_map.get(instr.offset, instr.offset + 2)
     
     def _set_security_detection_flag(self, state: SymbolicMachineState, violation):
@@ -2744,8 +2759,9 @@ class SymbolicVM:
                         return
                     self.solver.pop()
                     
-                    # Unpack elements and push onto stack (in order)
-                    for i in range(count):
+                    # Unpack elements and push onto stack in REVERSE order
+                    # so that TOS = first element (matches CPython semantics)
+                    for i in range(count - 1, -1, -1):
                         if i in seq_obj.elements:
                             frame.operand_stack.append(seq_obj.elements[i])
                         else:
@@ -2754,12 +2770,12 @@ class SymbolicVM:
                             frame.operand_stack.append(sym_elem)
                 else:
                     # Sequence object not found in heap - create symbolic unpacked values
-                    for i in range(count):
+                    for i in range(count - 1, -1, -1):
                         sym_elem = SymbolicValue(ValueTag.OBJ, z3.Int(f"unpack_unknown_{id(seq)}_{i}"))
                         frame.operand_stack.append(sym_elem)
             else:
                 # Could not extract concrete obj_id - create symbolic unpacked values
-                for i in range(count):
+                for i in range(count - 1, -1, -1):
                     sym_elem = SymbolicValue(ValueTag.OBJ, z3.Int(f"unpack_symbolic_{id(seq)}_{i}"))
                     frame.operand_stack.append(sym_elem)
             
@@ -2767,15 +2783,16 @@ class SymbolicVM:
         
         elif opname == "STORE_SUBSCR":
             # STORE_SUBSCR: Implements container[index] = value
-            # Stack: value, container, index → (empty)
-            # Pops all three and stores value at container[index]
+            # CPython stack layout: [..., value, container, index]
+            # TOS=index, TOS1=container, TOS2=value
+            # Pop order: index, container, value
             if len(frame.operand_stack) < 3:
                 state.exception = "StackUnderflow"
                 return
             
-            value = frame.operand_stack.pop()
-            container = frame.operand_stack.pop()
-            index = frame.operand_stack.pop()
+            index = frame.operand_stack.pop()      # TOS
+            container = frame.operand_stack.pop()  # TOS1
+            value = frame.operand_stack.pop()      # TOS2
             
             # Check for None misuse on container
             self.solver.push()
@@ -5515,11 +5532,16 @@ class SymbolicVM:
             # argval is an index into a common constants table
             const_repr = instr.argrepr
             
-            # Common exception types
+            # Common exception types (including NotImplementedError which is
+            # raised by compiler-generated __annotate__ functions in Python 3.14+)
             exception_types = ['AssertionError', 'RuntimeError', 'ValueError', 'TypeError', 
                              'KeyError', 'IndexError', 'AttributeError', 'ImportError',
                              'NameError', 'OSError', 'IOError', 'ZeroDivisionError',
                              'StopIteration', 'StopAsyncIteration', 'SystemExit',
+                             'NotImplementedError', 'OverflowError', 'UnicodeError',
+                             'UnicodeDecodeError', 'UnicodeEncodeError',
+                             'FileNotFoundError', 'PermissionError', 'TimeoutError',
+                             'ConnectionError', 'BrokenPipeError',
                              'BaseException', 'Exception']
             
             matched_exc = None
@@ -5913,66 +5935,52 @@ class SymbolicVM:
                 state.exception = "InfeasiblePath"
         
         elif opname == "PUSH_EXC_INFO":
-            # Push exception info onto stack when entering exception handler
-            # In Python 3.11+, this pushes the current exception onto the stack
-            # Stack layout: [exc_type, exc_value, exc_traceback, ...]
+            # Python 3.11+: PUSH_EXC_INFO pushes (prev_exc, new_exc)
+            # prev_exc is the previous exception (None if none), new_exc is the current one
             if state.exception:
-                # Push exception info as symbolic values
-                # Look up the exception type from builtins to get the correct payload
+                # Create the exception value with proper type info
                 if state.exception in frame.builtins:
-                    exc_type_val = frame.builtins[state.exception]
+                    exc_val = frame.builtins[state.exception]
                 else:
-                    # Unknown exception, use a generic marker
-                    exc_type_val = SymbolicValue(ValueTag.OBJ, z3.IntVal(-2))
-                    exc_type_val._exception_type = state.exception
+                    exc_val = SymbolicValue(ValueTag.OBJ, z3.IntVal(-2))
+                    exc_val._exception_type = state.exception
                 
-                exc_value_val = state.exception_value if state.exception_value else SymbolicValue.none()
-                exc_tb_val = SymbolicValue.none()  # Traceback representation (simplified)
-                
-                frame.operand_stack.extend([exc_type_val, exc_value_val, exc_tb_val])
+                # Push prev_exc (simplified as None) and current exception
+                prev_exc = SymbolicValue.none()
+                frame.operand_stack.append(prev_exc)   # prev_exc
+                frame.operand_stack.append(exc_val)     # current exc
             frame.instruction_offset = self._next_offset(frame, instr)
         
         elif opname == "CHECK_EXC_MATCH":
-            # Check if TOS (exception type to match) matches current exception
-            # Stack before: [..., exc_type, exc_value, exc_tb, match_type]
-            # Stack after: [..., exc_type, exc_value, exc_tb, match_result]
-            if len(frame.operand_stack) < 4:
+            # Python 3.11+: CHECK_EXC_MATCH (left, right -- left, bool)
+            # TOS = match_type (exception class to compare against)
+            # TOS1 = exc_value (stays on stack)
+            # Result: pushes boolean indicating whether exc matches match_type
+            if len(frame.operand_stack) < 2:
                 state.exception = "StackUnderflow"
                 return
             
-            match_type = frame.operand_stack.pop()
-            # exc_tb, exc_value, exc_type are still on stack
-            
-            # Get the actual exception from the stack
-            if len(frame.operand_stack) >= 3:
-                exc_tb = frame.operand_stack[-1]
-                exc_value = frame.operand_stack[-2]
-                exc_type = frame.operand_stack[-3]
-                
-                # Check if exception matches by comparing payloads symbolically
-                # Exception types are represented as OBJ with distinct payload values
-                if exc_type.tag == ValueTag.OBJ and match_type.tag == ValueTag.OBJ:
-                    # Create symbolic comparison: exc_type.payload == match_type.payload
-                    matches_expr = exc_type.payload == match_type.payload
-                    match_result = SymbolicValue(ValueTag.BOOL, matches_expr)
-                    frame.operand_stack.append(match_result)
-                else:
-                    # Unknown types, conservatively assume it could match
-                    frame.operand_stack.append(SymbolicValue.bool(True))
+            match_type = frame.operand_stack.pop()    # TOS = type to match
+            exc_value = frame.operand_stack[-1]        # TOS1 = stays on stack
+            
+            # Compare exception types
+            if hasattr(exc_value, '_exception_type') and hasattr(match_type, '_exception_type'):
+                matches = exc_value._exception_type == match_type._exception_type
+                frame.operand_stack.append(SymbolicValue.bool(matches))
+            elif exc_value.tag == ValueTag.OBJ and match_type.tag == ValueTag.OBJ:
+                matches_expr = exc_value.payload == match_type.payload
+                match_result = SymbolicValue(ValueTag.BOOL, matches_expr)
+                frame.operand_stack.append(match_result)
             else:
-                state.exception = "StackUnderflow"
-                return
+                # Unknown types, conservatively assume it could match
+                frame.operand_stack.append(SymbolicValue.bool(True))
             
             frame.instruction_offset = self._next_offset(frame, instr)
         
         elif opname == "POP_EXCEPT":
-            # Pop exception state and clear current exception
-            # This happens when exiting an exception handler successfully
-            # Stack: [exc_type, exc_value, exc_tb, ...] -> [...]
-            if len(frame.operand_stack) >= 3:
-                frame.operand_stack.pop()  # exc_tb
-                frame.operand_stack.pop()  # exc_value
-                frame.operand_stack.pop()  # exc_type
+            # Python 3.11+: POP_EXCEPT pops one value (the exception)
+            if frame.operand_stack:
+                frame.operand_stack.pop()
             
             # Clear exception state
             state.exception = None
@@ -6015,11 +6023,11 @@ class SymbolicVM:
             elif var_index < num_varnames + num_cellvars:
                 # This is a cellvar (variable in this function that inner functions will reference)
                 cell_index = var_index - num_varnames
-                frame.cells[cell_index] = None  # Initialize as empty cell
+                frame.cells[cell_index] = SymbolicValue.none()  # Initialize as empty cell
             else:
                 # This is a freevar (variable from outer scope)
                 freevar_index = var_index - num_varnames - num_cellvars
-                frame.freevars[freevar_index] = None  # Initialize as empty
+                frame.freevars[freevar_index] = SymbolicValue.none()  # Initialize as empty
             
             frame.instruction_offset = self._next_offset(frame, instr)
         
@@ -6757,7 +6765,7 @@ class SymbolicVM:
             
             # Convert to boolean using is_true helper
             # is_true returns z3.ExprRef (BoolRef), we need to wrap it in a SymbolicValue
-            bool_expr = is_true(val, state)
+            bool_expr = is_true(val, self.solver)
             bool_val = SymbolicValue(
                 ValueTag.BOOL,
                 z3.If(bool_expr, z3.IntVal(1), z3.IntVal(0))
@@ -6835,11 +6843,12 @@ class SymbolicVM:
                 state.exception = "StackUnderflow"
                 return
             
-            value = frame.operand_stack.pop()
-            func = frame.operand_stack[-1]  # Keep function on stack
+            func = frame.operand_stack.pop()   # TOS = function
+            attr = frame.operand_stack.pop()   # TOS1 = attribute value (consumed)
+            frame.operand_stack.append(func)   # Push function back on stack
             
             # For symbolic execution, we don't need to track these attributes yet
-            # Just consume the value and keep the function
+            # Just consume the attr value and keep the function
             
             frame.instruction_offset = self._next_offset(frame, instr)
         
@@ -7822,7 +7831,7 @@ class SymbolicVM:
                 # Converts list to tuple (structural operation)
                 # Symbolically: create a fresh tuple object
                 tuple_id = z3.Int(f"intrinsic_tuple_{instr.offset}_{id(frame)}")
-                tuple_obj = SymbolicValue(ValueTag.OBJ, tuple_id)
+                tuple_obj = SymbolicValue(ValueTag.TUPLE, tuple_id)  # ✓ Correct: TUPLE not OBJ
                 frame.operand_stack.append(tuple_obj)
                 frame.instruction_offset = self._next_offset(frame, instr)
             else:

{a3_python-0.1.19 → a3_python-0.1.21}/a3_python/z3model/values.py

@@ -131,7 +131,7 @@ class SymbolicValue:
         sym = z3.Bool(name)
         if solver:
             solver.add(True)
-        return SymbolicValue.bool(z3.If(sym, z3.IntVal(1), z3.IntVal(0)))
+        return SymbolicValue.bool(sym)
     
     @staticmethod
     def fresh_obj(name: str, solver: z3.Solver = None) -> 'SymbolicValue':
@@ -495,8 +495,23 @@ def binary_op_floordiv(left: SymbolicValue, right: SymbolicValue, solver: z3.Sol
         z3.And(right.is_float(), right.as_float() == z3.RealVal(0))
     )
     
-    # For int // int, use integer division; for any float involvement, use real division
-    result_int = left.as_int() / right.as_int()
+    # For int // int, use Python floor division.
+    # Z3's integer `/` is Euclidean division (remainder always non-negative),
+    # which differs from Python's floor division when the divisor is negative.
+    # Python: 7 // -2 = -4, but Z3: 7 / -2 = -3
+    # Fix: adjust when divisor is negative and there's a nonzero remainder.
+    # Guard: Z3's `%` requires IntSort, so only build this path for int payloads.
+    if z3.is_int(left.payload) and z3.is_int(right.payload):
+        euclid_div = left.as_int() / right.as_int()
+        euclid_mod = left.as_int() % right.as_int()
+        result_int = z3.If(
+            z3.And(right.as_int() < 0, euclid_mod != 0),
+            euclid_div - 1,
+            euclid_div
+        )
+    else:
+        # Float inputs: int path unused; dummy with correct sort for z3.If
+        result_int = z3.IntVal(0)
     
     # Convert to float using Z3 sort checking
     left_val = left.payload
@@ -512,7 +527,9 @@ def binary_op_floordiv(left: SymbolicValue, right: SymbolicValue, solver: z3.Sol
     else:
         right_as_float = right_val
     
-    result_float = left_as_float / right_as_float
+    # For float floor division, compute floor of the real quotient.
+    # z3.ToInt is floor for reals, then convert back to Real for float result.
+    result_float = z3.ToReal(z3.ToInt(left_as_float / right_as_float))
     
     is_numeric_float = z3.Or(both_floats, int_float, float_int)
     result_payload = z3.If(is_numeric_float, result_float, result_int)
@@ -552,8 +569,22 @@ def binary_op_mod(left: SymbolicValue, right: SymbolicValue, solver: z3.Solver)
         z3.And(right.is_float(), right.as_float() == z3.RealVal(0))
     )
     
-    # For int % int, use integer modulo
-    result_int = left.as_int() % right.as_int()
+    # For int % int, use Python floor modulo.
+    # Z3's integer `%` is Euclidean mod (always non-negative),
+    # which differs from Python's floor mod when the divisor is negative.
+    # Python: 7 % -2 = -1, but Z3: 7 % -2 = 1
+    # Fix: adjust when divisor is negative and there's a nonzero remainder.
+    # Guard: Z3's `%` requires IntSort, so only build this path for int payloads.
+    if z3.is_int(left.payload) and z3.is_int(right.payload):
+        euclid_mod = left.as_int() % right.as_int()
+        result_int = z3.If(
+            z3.And(right.as_int() < 0, euclid_mod != 0),
+            euclid_mod + right.as_int(),
+            euclid_mod
+        )
+    else:
+        # Float inputs: int path unused; dummy with correct sort for z3.If
+        result_int = z3.IntVal(0)
     
     # For float modulo, we approximate (Z3 doesn't have built-in real modulo)
     # Convert to float using Z3 sort checking
@@ -759,16 +790,26 @@ def compare_op_lt(left: SymbolicValue, right: SymbolicValue, solver: z3.Solver)
     """Symbolic less-than comparison."""
     # Accept OBJ types (conservative overapproximation for soundness)
     # OBJ might be anything, including comparable types
+    # Also accept float and mixed int/float comparisons
     type_ok = z3.Or(
         z3.And(left.is_int(), right.is_int()),
+        z3.And(left.is_float(), right.is_float()),
+        z3.And(left.is_int(), right.is_float()),
+        z3.And(left.is_float(), right.is_int()),
         left.is_obj(),
         right.is_obj()
     )
     # When OBJ involved, return nondeterministic result (sound overapproximation)
+    # For float comparisons, as_float() returns payload; Z3 auto-coerces Int→Real
+    any_float = z3.Or(left.is_float(), right.is_float())
     result_val = z3.If(
         z3.Or(left.is_obj(), right.is_obj()),
         z3.Int(f"cmp_lt_obj_{id(left)}_{id(right)}"),
-        z3.If(left.as_int() < right.as_int(), z3.IntVal(1), z3.IntVal(0))
+        z3.If(
+            any_float,
+            z3.If(left.as_float() < right.as_float(), z3.IntVal(1), z3.IntVal(0)),
+            z3.If(left.as_int() < right.as_int(), z3.IntVal(1), z3.IntVal(0))
+        )
     )
     return SymbolicValue(ValueTag.BOOL, result_val), type_ok
 
@@ -776,16 +817,25 @@ def compare_op_lt(left: SymbolicValue, right: SymbolicValue, solver: z3.Solver)
 def compare_op_le(left: SymbolicValue, right: SymbolicValue, solver: z3.Solver) -> tuple[SymbolicValue, z3.ExprRef]:
     """Symbolic less-than-or-equal comparison."""
     # Accept OBJ types (conservative overapproximation for soundness)
+    # Also accept float and mixed int/float comparisons
     type_ok = z3.Or(
         z3.And(left.is_int(), right.is_int()),
+        z3.And(left.is_float(), right.is_float()),
+        z3.And(left.is_int(), right.is_float()),
+        z3.And(left.is_float(), right.is_int()),
         left.is_obj(),
         right.is_obj()
     )
     # When OBJ involved, return nondeterministic result (sound overapproximation)
+    any_float = z3.Or(left.is_float(), right.is_float())
     result_val = z3.If(
         z3.Or(left.is_obj(), right.is_obj()),
         z3.Int(f"cmp_le_obj_{id(left)}_{id(right)}"),
-        z3.If(left.as_int() <= right.as_int(), z3.IntVal(1), z3.IntVal(0))
+        z3.If(
+            any_float,
+            z3.If(left.as_float() <= right.as_float(), z3.IntVal(1), z3.IntVal(0)),
+            z3.If(left.as_int() <= right.as_int(), z3.IntVal(1), z3.IntVal(0))
+        )
     )
     return SymbolicValue(ValueTag.BOOL, result_val), type_ok
 
@@ -899,16 +949,25 @@ def compare_op_ne(left: SymbolicValue, right: SymbolicValue, solver: z3.Solver)
 def compare_op_gt(left: SymbolicValue, right: SymbolicValue, solver: z3.Solver) -> tuple[SymbolicValue, z3.ExprRef]:
     """Symbolic greater-than comparison."""
     # Accept OBJ types (conservative overapproximation for soundness)
+    # Also accept float and mixed int/float comparisons
     type_ok = z3.Or(
         z3.And(left.is_int(), right.is_int()),
+        z3.And(left.is_float(), right.is_float()),
+        z3.And(left.is_int(), right.is_float()),
+        z3.And(left.is_float(), right.is_int()),
         left.is_obj(),
         right.is_obj()
     )
     # When OBJ involved, return nondeterministic result (sound overapproximation)
+    any_float = z3.Or(left.is_float(), right.is_float())
     result_val = z3.If(
         z3.Or(left.is_obj(), right.is_obj()),
         z3.Int(f"cmp_gt_obj_{id(left)}_{id(right)}"),
-        z3.If(left.as_int() > right.as_int(), z3.IntVal(1), z3.IntVal(0))
+        z3.If(
+            any_float,
+            z3.If(left.as_float() > right.as_float(), z3.IntVal(1), z3.IntVal(0)),
+            z3.If(left.as_int() > right.as_int(), z3.IntVal(1), z3.IntVal(0))
+        )
     )
     return SymbolicValue(ValueTag.BOOL, result_val), type_ok
 
@@ -916,16 +975,25 @@ def compare_op_gt(left: SymbolicValue, right: SymbolicValue, solver: z3.Solver)
 def compare_op_ge(left: SymbolicValue, right: SymbolicValue, solver: z3.Solver) -> tuple[SymbolicValue, z3.ExprRef]:
     """Symbolic greater-than-or-equal comparison."""
     # Accept OBJ types (conservative overapproximation for soundness)
+    # Also accept float and mixed int/float comparisons
     type_ok = z3.Or(
         z3.And(left.is_int(), right.is_int()),
+        z3.And(left.is_float(), right.is_float()),
+        z3.And(left.is_int(), right.is_float()),
+        z3.And(left.is_float(), right.is_int()),
         left.is_obj(),
         right.is_obj()
     )
     # When OBJ involved, return nondeterministic result (sound overapproximation)
+    any_float = z3.Or(left.is_float(), right.is_float())
     result_val = z3.If(
         z3.Or(left.is_obj(), right.is_obj()),
         z3.Int(f"cmp_ge_obj_{id(left)}_{id(right)}"),
-        z3.If(left.as_int() >= right.as_int(), z3.IntVal(1), z3.IntVal(0))
+        z3.If(
+            any_float,
+            z3.If(left.as_float() >= right.as_float(), z3.IntVal(1), z3.IntVal(0)),
+            z3.If(left.as_int() >= right.as_int(), z3.IntVal(1), z3.IntVal(0))
+        )
     )
     return SymbolicValue(ValueTag.BOOL, result_val), type_ok
 
@@ -992,8 +1060,14 @@ def is_true(value: SymbolicValue, solver: z3.Solver) -> z3.ExprRef:
         value.payload == z3.IntVal(0)
     )
     
-    # Value is false if it's None, False, or 0
-    is_false = z3.Or(is_none, is_false_bool, is_zero_int)
+    # Float 0.0 → False
+    is_zero_float = z3.And(
+        value.tag == z3.IntVal(ValueTag.FLOAT.value),
+        value.payload == z3.RealVal(0)
+    )
+    
+    # Value is false if it's None, False, 0, or 0.0
+    is_false = z3.Or(is_none, is_false_bool, is_zero_int, is_zero_float)
     
     # Value is true if it's not false
     return z3.Not(is_false)
@@ -1112,9 +1186,11 @@ def binary_op_subscript(container: SymbolicValue, index: SymbolicValue, heap, so
                             solver.pop()
                             return result, type_ok, bounds_violated, none_misuse
             
-            # Symbolic dict or symbolic key: conservatively assume may raise KeyError
+            # Symbolic dict or symbolic key: create symbolic bounds check
+            # KeyError is possible but not certain (e.g., if key is validated)
             result = SymbolicValue.fresh_int("dict_subscript_symbolic", solver)
-            bounds_violated = z3.BoolVal(True)  # Conservative: may raise KeyError
+            bounds_violated = z3.Bool(f"dict_key_missing_{id(container)}_{id(index)}")
+            # Add constraint: allow both paths (key exists / key missing)
             solver.pop()
             return result, type_ok, bounds_violated, none_misuse
         solver.pop()

{a3_python-0.1.19 → a3_python-0.1.21}/a3_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: a3-python
-Version: 0.1.19
+Version: 0.1.21
 Summary: Catch real Python bugs before production — 99%+ accuracy, Z3 symbolic execution, LLM-powered false-positive filtering, zero-config GitHub CI
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{a3_python-0.1.19 → a3_python-0.1.21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "a3-python"
-version = "0.1.19"
+version = "0.1.21"
 description = "Catch real Python bugs before production — 99%+ accuracy, Z3 symbolic execution, LLM-powered false-positive filtering, zero-config GitHub CI"
 readme = "README.md"
 requires-python = ">=3.11"