crosshair-tool 0.0.95__cp38-cp38-win32.whl → 0.0.97__cp38-cp38-win32.whl

crosshair/libimpl/builtinslib_test.py

@@ -939,6 +939,31 @@ def test_str_replace_method() -> None:
     check_states(f, POST_FAIL)
 
 
+def test_str_startswith(space) -> None:
+    symbolic_char = proxy_for_type(str, "x")
+    symbolic_empty = proxy_for_type(str, "y")
+    with ResumedTracing():
+        space.add(len(symbolic_char) == 1)
+        space.add(len(symbolic_empty) == 0)
+        assert symbolic_char.startswith(symbolic_empty)
+        assert symbolic_char.startswith(symbolic_char)
+        assert symbolic_char.startswith(("foo", symbolic_empty))
+        assert not symbolic_char.startswith(("foo", "bar"))
+        assert symbolic_char.startswith(("", "bar"))
+        assert symbolic_char.startswith("")
+        assert symbolic_char.startswith(symbolic_empty, 1)
+        assert symbolic_char.startswith(symbolic_empty, 1, 1)
+        assert str.startswith(symbolic_char, symbolic_empty)
+        assert "foo".startswith(symbolic_empty)
+        assert not "".startswith(symbolic_char)
+
+        # Yes, the empty string is findable off the left side but not the right
+        assert "x".startswith("", -10, -9)
+        assert symbolic_char.startswith(symbolic_empty, -10, -9)
+        assert not "x".startswith("", 9, 10)
+        assert not symbolic_char.startswith(symbolic_empty, 9, 10)
+
+
 @pytest.mark.demo
 def test_str_index_method() -> None:
     def f(a: str) -> int:
@@ -1425,7 +1450,7 @@ def test_str_lower():
 
 
 def test_str_title():
-    chr_lj = "\u01C9"  # "lj"
+    chr_lj = "\u01c9"  # "lj"
     chr_Lj = "\u01c8"  # "Lj" (different from "LJ", "\u01c7")
     with standalone_statespace:
         with NoTracing():
@@ -2624,6 +2649,7 @@ if sys.version_info >= (3, 9):
 def test_set_basic_fail() -> None:
     def f(a: Set[int], k: int) -> None:
         """
+        pre: len(a) <= 2
         post[a]: k+1 in a
         """
         a.add(k)
@@ -3134,6 +3160,17 @@ def test_callable_as_bool() -> None:
     check_states(f, CONFIRMED)
 
 
+def test_callable_can_return_different_values(space) -> None:
+    fn = proxy_for_type(Callable[[], int], "fn")
+    with ResumedTracing():
+        first_return = fn()
+        second_return = fn()
+        returns_are_equal = first_return == second_return
+        returns_are_not_equal = first_return != second_return
+    assert space.is_possible(returns_are_equal)
+    assert space.is_possible(returns_are_not_equal)
+
+
 @pytest.mark.smoke
 def test_callable_repr() -> None:
     def f(f1: Callable[[int], int]) -> int:

crosshair/libimpl/collectionslib_test.py

@@ -3,7 +3,7 @@ import sys
 from collections import Counter, defaultdict, deque, namedtuple
 from copy import deepcopy
 from inspect import Parameter, Signature
-from typing import Counter, DefaultDict, Deque, NamedTuple, Tuple
+from typing import Callable, Counter, DefaultDict, Deque, Dict, NamedTuple, Tuple
 
 import pytest
 
@@ -14,7 +14,7 @@ from crosshair.core import (
     realize,
     standalone_statespace,
 )
-from crosshair.libimpl.collectionslib import ListBasedDeque
+from crosshair.libimpl.collectionslib import ListBasedDeque, PureDefaultDict
 from crosshair.statespace import CANNOT_CONFIRM, CONFIRMED, POST_FAIL, MessageType
 from crosshair.test_util import check_states
 from crosshair.tracers import NoTracing, ResumedTracing
@@ -246,10 +246,10 @@ def test_defaultdict_default_fail(test_list) -> None:
 
 
 def test_defaultdict_default_ok(test_list) -> None:
-    def f(a: DefaultDict[int, int], k1: int, k2: int) -> DefaultDict[int, int]:
+    def f(a: DefaultDict[int, int], k: int) -> DefaultDict[int, int]:
         """
         pre: len(a) == 0 and a.default_factory is not None
-        post: _[k1] == _[k2]
+        post: _[k] == _[k]
         """
         return a
 

crosshair/libimpl/datetimelib.py

@@ -627,9 +627,7 @@ class timedelta:
 
     def total_seconds(self):
         """Total seconds in the duration."""
-        return (
-            (self.days * 86400 + self.seconds) * 10**6 + self.microseconds
-        ) / 10**6
+        return ((self.days * 86400 + self.seconds) * 10**6 + self.microseconds) / 10**6
 
     # Read-only field accessors
     @property

crosshair/libimpl/datetimelib_ch_test.py

@@ -29,7 +29,7 @@ def check_datetimelib_lt(
         Tuple[timedelta, timedelta],
         Tuple[date, datetime],
         Tuple[datetime, datetime],
-    ]
+    ],
 ) -> ResultComparison:
     """post: _"""
     return compare_results(operator.lt, *p)
@@ -40,7 +40,7 @@ def check_datetimelib_add(
         Tuple[timedelta, timedelta],
         Tuple[date, timedelta],
         Tuple[timedelta, datetime],
-    ]
+    ],
 ) -> ResultComparison:
     """post: _"""
     return compare_results(operator.add, *p)
@@ -52,14 +52,14 @@ def check_datetimelib_subtract(
         Tuple[date, timedelta],
         Tuple[datetime, timedelta],
         Tuple[datetime, datetime],
-    ]
+    ],
 ) -> ResultComparison:
     """post: _"""
     return compare_results(operator.sub, *p)
 
 
 def check_datetimelib_str(
-    obj: Union[timedelta, timezone, date, time, datetime]
+    obj: Union[timedelta, timezone, date, time, datetime],
 ) -> ResultComparison:
     """post: _"""
     return compare_results(_invoker("__str__"), obj)
@@ -67,7 +67,7 @@ def check_datetimelib_str(
 
 def check_datetimelib_repr(
     # TODO: re-enable time, datetime repr checking after fixing in Python 3.11
-    obj: Union[timedelta, timezone, date]
+    obj: Union[timedelta, timezone, date],
 ) -> ResultComparison:
     """post: _"""
     return compare_results(_invoker("__repr__"), obj)

crosshair/libimpl/encodings/_encutil.py

@@ -25,6 +25,7 @@ class UnexpectedEndError(ChunkError):
 @dataclass
 class MidChunkError(ChunkError):
     _reason: str
+
     # _errlen: int = 1
     def reason(self) -> str:
         return self._reason
@@ -112,7 +113,7 @@ class StemEncoder:
                     continue
                 if errors == "replace":
                     idx += 1
-                    parts.append("\uFFFD")
+                    parts.append("\ufffd")
                     continue
 
                 # 2. Then fall back to native implementations if necessary:
@@ -132,24 +133,28 @@ class StemEncoder:
 
 def _getregentry(stem_encoder: Type[StemEncoder]):
     class StemIncrementalEncoder(codecs.BufferedIncrementalEncoder):
-        def _buffer_encode(self, input: str, errors: str, final: bool) -> bytes:
+        def _buffer_encode(
+            self, input: str, errors: str, final: bool
+        ) -> Tuple[bytes, int]:
             enc_name = stem_encoder.encoding_name
             out, idx, err = stem_encoder._encode_chunk(input, 0)
             assert isinstance(out, bytes)
             if not err:
-                return out
+                return (out, idx)
             if isinstance(err, UnexpectedEndError) or not final:
-                return out
+                return (out, idx)
             exc = UnicodeEncodeError(enc_name, input, idx, idx + 1, err.reason())
             replacement, idx = codecs.lookup_error(errors)(exc)
             if isinstance(replacement, str):
                 replacement = codecs.encode(replacement, enc_name)
-            return out + replacement
+            return (out + replacement, idx)
 
     class StemIncrementalDecoder(codecs.BufferedIncrementalDecoder):
         def _buffer_decode(
-            self, input: bytes, errors: str, final: bool
+            self, input: Buffer, errors: str, final: bool
         ) -> Tuple[str, int]:
+            if not isinstance(input, bytes):
+                input = memoryview(input).tobytes()
             enc_name = stem_encoder.encoding_name
             out, idx, err = stem_encoder._decode_chunk(input, 0)
             assert isinstance(out, str)

crosshair/libimpl/functoolslib.py

@@ -1,4 +1,4 @@
-from functools import _lru_cache_wrapper, partial, reduce
+from functools import _lru_cache_wrapper, partial, reduce, update_wrapper, wraps
 
 from crosshair.core import register_patch
 
@@ -7,7 +7,13 @@ from crosshair.core import register_patch
 
 def _partial(func, *a1, **kw1):
     if callable(func):
-        return partial(lambda *a2, **kw2: func(*a2, **kw2), *a1, **kw1)
+        # We make a do-nothing wrapper to ensure that the tracer has a crack
+        # at this function when it is called.
+        def wrapper(*a2, **kw2):
+            return func(*a2, **kw2)
+
+        update_wrapper(wrapper, func)
+        return partial(wrapper, *a1, **kw1)
     else:
         raise TypeError
 

crosshair/libimpl/functoolslib_test.py

@@ -1,20 +1,36 @@
 import functools
+import inspect
 
 from crosshair.core import proxy_for_type, standalone_statespace
 from crosshair.libimpl.builtinslib import LazyIntSymbolicStr
-from crosshair.tracers import NoTracing
+from crosshair.tracers import NoTracing, ResumedTracing
 
 
-def test_partial():
-    with standalone_statespace as space:
-        with NoTracing():
-            abc = LazyIntSymbolicStr(list(map(ord, "abc")))
-            xyz = LazyIntSymbolicStr(list(map(ord, "xyz")))
+def test_partial(space):
+    abc = LazyIntSymbolicStr(list(map(ord, "abc")))
+    xyz = LazyIntSymbolicStr(list(map(ord, "xyz")))
+    with ResumedTracing():
         joiner = functools.partial(str.join, ",")
         ret = joiner([abc, xyz])
         assert ret == "abc,xyz"
 
 
+def test_partial_is_interceptable(space):
+    x = proxy_for_type(str, "x")
+    y = proxy_for_type(str, "y")
+    with ResumedTracing():
+        joiner = functools.partial(str.startswith, x)
+        # Ensure we don't explode
+        list(map(joiner, ["foo", y]))
+
+
+def test_partial_arg_is_inspectable(space):
+    with ResumedTracing():
+        joiner = functools.partial(str.join, ",")
+        assert isinstance(joiner, functools.partial)
+        assert inspect.getdoc(joiner.func) == inspect.getdoc(str.join)
+
+
 def test_reduce():
     with standalone_statespace as space:
         with NoTracing():

crosshair/libimpl/relib.py

@@ -7,7 +7,7 @@ from unicodedata import category
 if sys.version_info < (3, 11):
     import sre_parse as re_parser
 else:
-    import re._parser as re_parser
+    import re._parser as re_parser  # type: ignore
 
 from sys import maxunicode
 from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union, cast

crosshair/libimpl/unicodedatalib_test.py

@@ -11,7 +11,7 @@ def test_numeric():
     with standalone_statespace as space:
         with NoTracing():
             fourstr = LazyIntSymbolicStr(list(map(ord, "4")))
-            halfstr = LazyIntSymbolicStr(list(map(ord, "\u00BD")))  # (1/2 character)
+            halfstr = LazyIntSymbolicStr(list(map(ord, "\u00bd")))  # (1/2 character)
         four = unicodedata.numeric(fourstr)
         half = unicodedata.numeric(halfstr)
         assert type(four) is float
@@ -22,7 +22,7 @@ def test_numeric():
 def test_decimal():
     with standalone_statespace as space:
         with NoTracing():
-            thai4 = LazyIntSymbolicStr(list(map(ord, "\u0E54")))  # (Thai numerial 4)
+            thai4 = LazyIntSymbolicStr(list(map(ord, "\u0e54")))  # (Thai numerial 4)
             super4 = LazyIntSymbolicStr(list(map(ord, "\u2074")))  # (superscript 4)
         four = unicodedata.decimal(thai4)
         assert type(four) is int
@@ -34,7 +34,7 @@ def test_decimal():
 def test_digit():
     with standalone_statespace as space:
         with NoTracing():
-            thai4 = LazyIntSymbolicStr(list(map(ord, "\u0E54")))  # (Thai numerial 4)
+            thai4 = LazyIntSymbolicStr(list(map(ord, "\u0e54")))  # (Thai numerial 4)
             super4 = LazyIntSymbolicStr(list(map(ord, "\u2074")))  # (superscript 4)
         four = unicodedata.digit(thai4)
         assert type(four) is int

crosshair/main.py

@@ -774,9 +774,11 @@ def cover(
                 ctxfn,
                 options,
                 args.coverage_type,
-                arg_formatter=format_boundargs_as_dictionary
-                if example_output_format == ExampleOutputFormat.ARG_DICTIONARY
-                else format_boundargs,
+                arg_formatter=(
+                    format_boundargs_as_dictionary
+                    if example_output_format == ExampleOutputFormat.ARG_DICTIONARY
+                    else format_boundargs
+                ),
             )
         except NotDeterministic:
             print(

crosshair/opcode_intercept.py

@@ -5,7 +5,9 @@ from collections import defaultdict
 from collections.abc import MutableMapping, Set
 from sys import version_info
 from types import CodeType, FrameType
-from typing import Any, Callable, Iterable, Mapping, Tuple, Union
+from typing import Any, Callable, Iterable, List, Mapping, Tuple, Union
+
+from z3 import ExprRef  # type: ignore
 
 from crosshair.core import (
     ATOMIC_IMMUTABLE_TYPES,
@@ -53,6 +55,7 @@ TO_BOOL = dis.opmap.get("TO_BOOL", 256)
 IS_OP = dis.opmap.get("IS_OP", 256)
 BINARY_MODULO = dis.opmap.get("BINARY_MODULO", 256)
 BINARY_OP = dis.opmap.get("BINARY_OP", 256)
+LOAD_COMMON_CONSTANT = dis.opmap.get("LOAD_COMMON_CONSTANT", 256)
 
 
 def frame_op_arg(frame):
@@ -83,13 +86,6 @@ class MultiSubscriptableContainer:
             if isinstance(container, Mapping):
                 kv_pairs: Iterable[Tuple[Any, Any]] = container.items()
             else:
-                in_bounds = space.smt_fork(
-                    z3Or(-len(container) <= key.var, key.var < len(container)),
-                    desc=f"index_in_bounds",
-                    probability_true=0.9,
-                )
-                if not in_bounds:
-                    raise IndexError
                 kv_pairs = enumerate(container)
 
             values_by_type = defaultdict(list)
@@ -118,7 +114,7 @@ class MultiSubscriptableContainer:
                 keys_by_value_id[id(cur_value)].append(cur_key)
             for value_type, cur_pairs in values_by_type.items():
                 hypothetical_result = symbolic_for_pytype(value_type)(
-                    "item_at_" + space.uniq(), value_type
+                    "item_" + space.uniq(), value_type
                 )
                 with ResumedTracing():
                     condition_pairs = []
@@ -139,20 +135,17 @@ class MultiSubscriptableContainer:
                         space.add(any([all(pair) for pair in condition_pairs]))
                         return hypothetical_result
 
-            for (value_id, value), probability_true in with_uniform_probabilities(
-                values_by_id.items()
-            ):
+            exprs_and_values: List[Tuple[ExprRef, object]] = []
+            for value_id, value in values_by_id.items():
                 keys_for_value = keys_by_value_id[value_id]
                 with ResumedTracing():
                     is_match = any([key == k for k in keys_for_value])
                 if isinstance(is_match, SymbolicBool):
-                    if space.smt_fork(
-                        is_match.var,
-                        probability_true=probability_true,
-                    ):
-                        return value
+                    exprs_and_values.append((is_match.var, value))
                 elif is_match:
                     return value
+            if exprs_and_values:
+                return space.smt_fanout(exprs_and_values, desc="multi_subscript")
 
             if type(container) is dict:
                 raise KeyError  # ( f"Key {key} not found in dict")
@@ -160,6 +153,39 @@ class MultiSubscriptableContainer:
                 raise IndexError  # (f"Index {key} out of range for list/tuple of length {len(container)}")
 
 
+class LoadCommonConstantInterceptor(TracingModule):
+    """
+    As of 3.14, the bytecode generation process generates optimizations
+    for builtins.any/all when invoked on a generator expression.
+    It essentially "inlines" the logic as bytecode.
+    We need to avoid this.
+    Before entering the optimized code path, it will check that the any/all
+    function is identity-equal to the original builtin, which is loaded using
+    the LOAD_COMMON_CONSTANT opcode.
+
+    This interceptor replaces that function with a proxy that functions
+    identically but is not identity-equal (so that we avoid the optimized
+    path),
+    """
+
+    opcodes_wanted = frozenset([LOAD_COMMON_CONSTANT])
+
+    def trace_op(self, frame, codeobj, codenum):
+        CONSTANT_BUILTIN_ALL = 3
+        CONSTANT_BUILTIN_ANY = 4
+        index = frame_op_arg(frame)
+
+        def post_op():
+            expected_fn = all if index == CONSTANT_BUILTIN_ALL else any
+            if CROSSHAIR_EXTRA_ASSERTS:
+                if frame_stack_read(frame, -1) is not expected_fn:
+                    raise CrossHairInternal
+            frame_stack_write(frame, -1, lambda *a: expected_fn(*a))
+
+        if index == CONSTANT_BUILTIN_ALL or index == CONSTANT_BUILTIN_ANY:
+            COMPOSITE_TRACER.set_postop_callback(post_op, frame)
+
+
 class SymbolicSubscriptInterceptor(TracingModule):
     opcodes_wanted = frozenset([BINARY_SUBSCR, BINARY_OP])
 
@@ -562,6 +588,8 @@ def make_registrations():
         register_opcode_patch(SymbolicSliceInterceptor())
     if sys.version_info < (3, 9):
         register_opcode_patch(ComparisonInterceptForwarder())
+    if sys.version_info >= (3, 14):
+        register_opcode_patch(LoadCommonConstantInterceptor())
     register_opcode_patch(ContainmentInterceptor())
     register_opcode_patch(BuildStringInterceptor())
     register_opcode_patch(FormatValueInterceptor())

crosshair/path_cover.py

@@ -133,7 +133,11 @@ def path_cover(
     selected: List[PathSummary] = []
     while paths:
         next_best = max(
-            paths, key=lambda p: len(p.coverage.offsets_covered - opcodes_found)
+            paths,
+            key=lambda p: (
+                len(p.coverage.offsets_covered - opcodes_found),  # high coverage
+                -len(p.formatted_args),  # with small input size
+            ),
         )
         cur_offsets = next_best.coverage.offsets_covered
         if coverage_type == CoverageType.OPCODE:

crosshair/pathing_oracle.py

@@ -11,9 +11,11 @@ from crosshair.statespace import (
     NodeLike,
     RootNode,
     SearchTreeNode,
+    StateSpace,
     WorstResultNode,
 )
 from crosshair.util import CrossHairInternal, debug, in_debug
+from crosshair.z3util import z3And, z3Not, z3Or
 
 CodeLoc = Tuple[str, ...]
 
@@ -60,7 +62,8 @@ class CoveragePathingOracle(AbstractPathingOracle):
     # (even just a 10% change could be much larger than it would be otherwise)
     _delta_probabilities = {-1: 0.1, 0: 0.25, 1: 0.9}
 
-    def pre_path_hook(self, root: RootNode) -> None:
+    def pre_path_hook(self, space: StateSpace) -> None:
+        root = space._root
         visits = self.visits
         _delta_probabilities = self._delta_probabilities
 
@@ -213,16 +216,50 @@ class PreferNegativeOracle(AbstractPathingOracle):
         return 0.25
 
 
+class ConstrainedOracle(AbstractPathingOracle):
+    """
+    A pathing oracle that prefers to take a path that satisfies
+    explicitly provided constraints.
+    """
+
+    def __init__(self, inner_oracle: AbstractPathingOracle):
+        self.inner_oracle = inner_oracle
+        self.exprs: List[ExprRef] = []
+
+    def prefer(self, expr: ExprRef):
+        self.exprs.append(expr)
+
+    def pre_path_hook(self, space: StateSpace) -> None:
+        self.space = space
+        self.exprs = []
+        self.inner_oracle.pre_path_hook(space)
+
+    def post_path_hook(self, path: Sequence["SearchTreeNode"]) -> None:
+        self.inner_oracle.post_path_hook(path)
+
+    def decide(
+        self, root, node: "WorstResultNode", engine_probability: Optional[float]
+    ) -> float:
+        # We always run the inner oracle in case it's tracking something about the path.
+        default_probability = self.inner_oracle.decide(root, node, engine_probability)
+        if not self.space.is_possible(z3And(*[node.expr, *self.exprs])):
+            return 0.0
+        elif not self.space.is_possible(z3And(*[z3Not(node.expr), *self.exprs])):
+            return 1.0
+        else:
+            return default_probability
+
+
 class RotatingOracle(AbstractPathingOracle):
     def __init__(self, oracles: List[AbstractPathingOracle]):
         self.oracles = oracles
         self.index = -1
 
-    def pre_path_hook(self, root: "RootNode") -> None:
+    def pre_path_hook(self, space: StateSpace) -> None:
         oracles = self.oracles
         self.index = (self.index + 1) % len(oracles)
         for oracle in oracles:
-            oracle.pre_path_hook(root)
+            oracle.pre_path_hook(space)
 
     def post_path_hook(self, path: Sequence["SearchTreeNode"]) -> None:
         for oracle in self.oracles:

crosshair/pathing_oracle_test.py

@@ -0,0 +1,21 @@
+import random
+
+import z3  # type: ignore
+
+from crosshair.pathing_oracle import ConstrainedOracle, PreferNegativeOracle
+from crosshair.statespace import RootNode, SimpleStateSpace, WorstResultNode
+
+
+def test_constrained_oracle():
+    oracle = ConstrainedOracle(PreferNegativeOracle())
+    x = z3.Int("x")
+    root = RootNode()
+    space = SimpleStateSpace()
+    oracle.pre_path_hook(space)
+    oracle.prefer(x >= 7)
+    rand = random.Random()
+    assert oracle.decide(root, WorstResultNode(rand, x < 7, space.solver), None) == 0.0
+    assert oracle.decide(root, WorstResultNode(rand, x >= 3, space.solver), None) == 1.0
+    assert (
+        oracle.decide(root, WorstResultNode(rand, x == 7, space.solver), None) == 0.25
+    )

crosshair/register_contract.py

@@ -1,4 +1,5 @@
 """API for registering contracts for external libraries."""
+
 from dataclasses import dataclass
 from inspect import Parameter, Signature, getmodule, ismethod, signature
 from types import MethodDescriptorType, ModuleType, WrapperDescriptorType

crosshair/register_contract_test.py

@@ -99,12 +99,10 @@ def test_register_numpy_randint():
 
 def test_register_overload():
     @overload
-    def overld(a: int) -> int:
-        ...
+    def overld(a: int) -> int: ...
 
     @overload
-    def overld(a: str) -> str:
-        ...
+    def overld(a: str) -> str: ...
 
     def overld(a: Union[int, str]) -> Union[int, str]:
         if isinstance(a, int):

crosshair/simplestructs.py

@@ -38,10 +38,10 @@ class MapBase(collections.abc.MutableMapping):
             return NotImplemented
         if len(self) != len(other):
             return False
-        for (k, self_value) in self.items():
+        for k, self_value in self.items():
             found = False
             # We do a slow nested loop search because we don't want to hash the key.
-            for (other_key, other_value) in other.items():
+            for other_key, other_value in other.items():
                 if other_key != k:
                     continue
                 if self_value == other_value:
@@ -122,7 +122,7 @@ class SimpleDict(MapBase):
     def __getitem__(self, key, default=_MISSING):
         if not is_hashable(key):
             raise TypeError("unhashable type")
-        for (k, v) in self.contents_:
+        for k, v in self.contents_:
             # Note that the identity check below is not just an optimization;
             # it is required to implement the semantics of NaN dict keys
             if k is key or k == key:
@@ -134,7 +134,7 @@ class SimpleDict(MapBase):
     def __setitem__(self, key, value):
         if not is_hashable(key):
             raise TypeError("unhashable type")
-        for (i, (k, v)) in enumerate(self.contents_):
+        for i, (k, v) in enumerate(self.contents_):
             if k == key:
                 self.contents_[i] = (k, value)
                 return
@@ -143,7 +143,7 @@ class SimpleDict(MapBase):
     def __delitem__(self, key):
         if not is_hashable(key):
             raise TypeError("unhashable type")
-        for (i, (k, v)) in enumerate(self.contents_):
+        for i, (k, v) in enumerate(self.contents_):
             if k == key:
                 del self.contents_[i]
                 return
@@ -493,9 +493,11 @@ class SequenceConcatenation(collections.abc.Sequence, SeqBase):
                     return second.__getitem__(
                         slice(
                             i.start - firstlen,
-                            i.stop
-                            if i.stop is None or i.stop < 0
-                            else i.stop - firstlen,
+                            (
+                                i.stop
+                                if i.stop is None or i.stop < 0
+                                else i.stop - firstlen
+                            ),
                             i.step,
                         )
                     )