bytecode 0.17.0__tar.gz → 0.18.1__tar.gz

{bytecode-0.17.0 → bytecode-0.18.1}/.github/workflows/cis.yml

@@ -20,9 +20,9 @@ jobs:
     name: Lint code
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: "3.12"
       - name: Install tools
@@ -42,26 +42,22 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - python-version: "3.9"
-            toxenv: py39
-          - python-version: "3.10"
-            toxenv: py310
           - python-version: "3.11"
             toxenv: py311
           - python-version: "3.12"
             toxenv: py312
           - python-version: "3.13"
             toxenv: py313
-          - python-version: "3.14-dev"
+          - python-version: "3.14"
             toxenv: py314
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Get history and tags for SCM versioning to work
         run: |
           git fetch --prune --unshallow
           git fetch --depth=1 origin +refs/tags/*:refs/tags/*
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install dependencies
@@ -74,7 +70,7 @@ jobs:
         run: |
           tox
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v6
         if: github.event_name != 'schedule'
         with:
           token: ${{ secrets.CODECOV_TOKEN }}

{bytecode-0.17.0 → bytecode-0.18.1}/.github/workflows/docs.yml

@@ -19,13 +19,13 @@ jobs:
     name: Docs building
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Get history and tags for SCM versioning to work
         run: |
           git fetch --prune --unshallow
           git fetch --depth=1 origin +refs/tags/*:refs/tags/*
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.x'
       - name: Install dependencies

{bytecode-0.17.0 → bytecode-0.18.1}/.github/workflows/frameworks.yml

@@ -21,15 +21,15 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
 
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}-dev
 

{bytecode-0.17.0 → bytecode-0.18.1}/.github/workflows/release.yml

@@ -13,13 +13,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Get history and tags for SCM versioning to work
         run: |
           git fetch --prune --unshallow
           git fetch --depth=1 origin +refs/tags/*:refs/tags/*
       - name: Setup Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.x'
       - name: Build sdist
@@ -33,7 +33,7 @@ jobs:
           pip install dist/*.tar.gz
           python -X dev -m pytest tests
       - name: Store artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: cibw-sdist
           path: dist/*
@@ -43,13 +43,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Get history and tags for SCM versioning to work
         run: |
           git fetch --prune --unshallow
           git fetch --depth=1 origin +refs/tags/*:refs/tags/*
       - name: Setup Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.x'
       - name: Build wheels
@@ -63,7 +63,7 @@ jobs:
           pip install dist/*.whl
           python -X dev -m pytest tests
       - name: Store artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: cibw-wheel
           path: dist/*.whl
@@ -74,12 +74,12 @@ jobs:
     runs-on: ubuntu-latest
     environment:
       name: pypi
-      url: https://pypi.org/p/kiwisolver
+      url: https://pypi.org/p/bytecode
     permissions:
       id-token: write
     steps:
       - name: Download all the dists
-        uses: actions/download-artifact@v5.0.0
+        uses: actions/download-artifact@v8.0.1
         with:
           pattern: cibw-*
           path: dist
@@ -101,13 +101,13 @@ jobs:
 
     steps:
     - name: Download all the dists
-      uses: actions/download-artifact@v5.0.0
+      uses: actions/download-artifact@v8.0.1
       with:
         pattern: cibw-*
         path: dist
         merge-multiple: true
     - name: Sign the dists with Sigstore
-      uses: sigstore/gh-action-sigstore-python@v3.0.1
+      uses: sigstore/gh-action-sigstore-python@v3.3.0
       with:
         inputs: >-
           ./dist/*.tar.gz

{bytecode-0.17.0 → bytecode-0.18.1}/.readthedocs.yaml

@@ -7,9 +7,9 @@ version: 2
 
 # Set the version of Python and other tools you might need
 build:
-  os: ubuntu-20.04
+  os: ubuntu-24.04
   tools:
-    python: "3.9"
+    python: "3.12"
 
 # Build documentation in the docs/source directory with Sphinx
 sphinx:

{bytecode-0.17.0/src/bytecode.egg-info → bytecode-0.18.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bytecode
-Version: 0.17.0
+Version: 0.18.1
 Summary: Python module to generate and modify bytecode
 Author-email: Victor Stinner <victor.stinner@gmail.com>
 Maintainer-email: "Matthieu C. Dartiailh" <m.dartiailh@gmail.com>
@@ -36,14 +36,12 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: COPYING
 Requires-Dist: typing_extensions; python_version < "3.10"

{bytecode-0.17.0 → bytecode-0.18.1}/doc/changelog.rst

@@ -1,6 +1,39 @@
 ChangeLog
 =========
 
+03-06-2026: Version 0.18.1
+--------------------------
+
+Bugfixes:
+
+- Fix an ``AssertionError`` in stack-size computation when a single exception
+  region is split into multiple ``TryBegin`` instances sharing one handler (as
+  produced by bytecode-rewriting tools that wrap a whole function body in a
+  single handler). ``TryBegin``/``TryEnd`` are now matched on the handler block
+  rather than on ``TryBegin`` identity.
+
+03-06-2026: Version 0.18.0
+--------------------------
+
+- drop support for Python 3.9 and 3.10 PR #180
+- Replace string literal type annotations with postponed evaluation using
+  ``from __future__ import annotations`` PR #191
+- multiple performance improvements
+  PRs #172, #193, #196, #194, #197, #198, #199, #200, #201,
+  #202, #203
+
+Breaking changes:
+
+- ``BasicBlock``, ``Bytecode``, and ``ConcreteBytecode`` now validate inserted
+  instructions at insertion time (``append``, ``extend``, ``insert``,
+  ``__setitem__``) rather than during iteration. Code that relied on catching
+  ``ValueError`` from ``list(block)`` or ``for instr in block:`` must wrap the
+  insertion call instead. PR #199
+
+Bugfixes:
+
+- Fix handling of END_ASYNC_FOR which is a backward jump PR #179
+
 03-09-2025: Version 0.17.0
 --------------------------
 

{bytecode-0.17.0 → bytecode-0.18.1}/pyproject.toml

@@ -2,7 +2,7 @@
   name = "bytecode"
   description = "Python module to generate and modify bytecode"
   readme = "README.rst"
-  requires-python = ">=3.9"
+  requires-python = ">=3.11"
   license = { file = "COPYING" }
   authors = [{ name = "Victor Stinner", email = "victor.stinner@gmail.com" }]
   maintainers = [{ name = "Matthieu C. Dartiailh", email = "m.dartiailh@gmail.com" }]
@@ -13,8 +13,6 @@
     "Natural Language :: English",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",

{bytecode-0.17.0 → bytecode-0.18.1}/src/bytecode/bytecode.py

@@ -1,5 +1,5 @@
-# alias to keep the 'bytecode' variable free
-import sys
+from __future__ import annotations
+
 import types
 from abc import abstractmethod
 from typing import (
@@ -16,6 +16,7 @@ from typing import (
     overload,
 )
 
+# alias to keep the 'bytecode' variable free
 import bytecode as _bytecode
 from bytecode.flags import CompilerFlags, infer_flags
 from bytecode.instr import (
@@ -28,7 +29,6 @@ from bytecode.instr import (
     TryBegin,
     TryEnd,
 )
-from bytecode.utils import PY311
 
 
 class BaseBytecode:
@@ -50,7 +50,7 @@ class BaseBytecode:
         self.freevars: List[str] = []
         self._flags: CompilerFlags = CompilerFlags(0)
 
-    def _copy_attr_from(self, bytecode: "BaseBytecode") -> None:
+    def _copy_attr_from(self, bytecode: BaseBytecode) -> None:
         self.argcount = bytecode.argcount
         self.posonlyargcount = bytecode.posonlyargcount
         self.kwonlyargcount = bytecode.kwonlyargcount
@@ -164,15 +164,33 @@ class _BaseBytecodeList(BaseBytecode, list, Generic[U]):
         for i in reversed(lineno_pos):
             del self[i]
 
-    def __iter__(self) -> Iterator[U]:
-        instructions = super().__iter__()
-        for instr in instructions:
-            self._check_instr(instr)
-            yield instr
-
     def _check_instr(self, instr):
         raise NotImplementedError()
 
+    def append(self, instr: U) -> None:  # type: ignore[override]
+        self._check_instr(instr)
+        super().append(instr)
+
+    def insert(self, index: SupportsIndex, instr: U) -> None:  # type: ignore[override]
+        self._check_instr(instr)
+        super().insert(index, instr)
+
+    def extend(self, instrs) -> None:  # type: ignore[override]
+        instrs = list(instrs)
+        for instr in instrs:
+            self._check_instr(instr)
+        super().extend(instrs)
+
+    def __setitem__(self, index, value):
+        if isinstance(index, slice):
+            values = list(value)
+            for v in values:
+                self._check_instr(v)
+            super().__setitem__(index, values)
+        else:
+            self._check_instr(value)
+            super().__setitem__(index, value)
+
 
 V = TypeVar("V")
 
@@ -242,15 +260,11 @@ class Bytecode(
     ) -> None:
         BaseBytecode.__init__(self)
         self.argnames: List[str] = []
-        for instr in instructions:
-            self._check_instr(instr)
         self.extend(instructions)
 
     def __iter__(self) -> Iterator[Union[Instr, Label, TryBegin, TryEnd, SetLineno]]:
-        instructions = super().__iter__()
         seen_try_begin = False
-        for instr in instructions:
-            self._check_instr(instr)
+        for instr in super().__iter__():
             if isinstance(instr, TryBegin):
                 if seen_try_begin:
                     raise RuntimeError("TryBegin pseudo instructions cannot be nested.")
@@ -277,7 +291,7 @@ class Bytecode(
         code: types.CodeType,
         prune_caches: bool = True,
         conserve_exception_block_stackdepth: bool = False,
-    ) -> "Bytecode":
+    ) -> Bytecode:
         concrete = _bytecode.ConcreteBytecode.from_code(code)
         return concrete.to_bytecode(
             prune_caches=prune_caches,
@@ -298,7 +312,7 @@ class Bytecode(
     ) -> types.CodeType:
         # Prevent reconverting the concrete bytecode to bytecode and cfg to do the
         # calculation if we need to do it.
-        if stacksize is None or (PY311 and compute_exception_stack_depths):
+        if stacksize is None or compute_exception_stack_depths:
             cfg = _bytecode.ControlFlowGraph.from_bytecode(self)
             stacksize = cfg.compute_stacksize(
                 check_pre_and_post=check_pre_and_post,
@@ -319,7 +333,7 @@ class Bytecode(
         self,
         compute_jumps_passes: Optional[int] = None,
         compute_exception_stack_depths: bool = True,
-    ) -> "_bytecode.ConcreteBytecode":
+    ) -> _bytecode.ConcreteBytecode:
         converter = _bytecode._ConvertBytecodeToConcrete(self)
         return converter.to_concrete_bytecode(
             compute_jumps_passes=compute_jumps_passes,

{bytecode-0.17.0 → bytecode-0.18.1}/src/bytecode/cfg.py

@@ -1,4 +1,5 @@
-import sys
+from __future__ import annotations
+
 import types
 from collections import defaultdict
 from dataclasses import dataclass
@@ -23,7 +24,7 @@ import bytecode as _bytecode
 from bytecode.concrete import ConcreteInstr
 from bytecode.flags import CompilerFlags
 from bytecode.instr import UNSET, Instr, Label, SetLineno, TryBegin, TryEnd
-from bytecode.utils import PY310, PY311, PY313
+from bytecode.utils import PY313
 
 T = TypeVar("T", bound="BasicBlock")
 U = TypeVar("U", bound="ControlFlowGraph")
@@ -37,43 +38,79 @@ class BasicBlock(_bytecode._InstrList[Union[Instr, SetLineno, TryBegin, TryEnd]]
         ] = None,
     ) -> None:
         # a BasicBlock object, or None
-        self.next_block: Optional["BasicBlock"] = None
+        self.next_block: Optional[BasicBlock] = None
         if instructions:
             super().__init__(instructions)
 
-    def __iter__(self) -> Iterator[Union[Instr, SetLineno, TryBegin, TryEnd]]:
-        index = 0
-        while index < len(self):
-            instr = self[index]
-            index += 1
+    _VALID_TYPES = (SetLineno, Instr, TryBegin, TryEnd)
+
+    @staticmethod
+    def _check_instr(instr: Any) -> None:
+        if not isinstance(instr, (SetLineno, Instr, TryBegin, TryEnd)):
+            raise ValueError(
+                "BasicBlock must only contain SetLineno and Instr objects, "
+                "but %s was found" % instr.__class__.__name__
+            )
 
-            if not isinstance(instr, (SetLineno, Instr, TryBegin, TryEnd)):
+    def append(self, instr: Union[Instr, SetLineno, TryBegin, TryEnd]) -> None:
+        self._check_instr(instr)
+        if isinstance(instr, Instr):
+            last = self.get_last_non_artificial_instruction()
+            if last is not None and last.has_jump():
                 raise ValueError(
-                    "BasicBlock must only contain SetLineno and Instr objects, "
-                    "but %s was found" % instr.__class__.__name__
+                    "Only the last instruction of a basic block can be a jump"
                 )
+        super().append(instr)
 
-            if isinstance(instr, Instr) and instr.has_jump():
-                if index < len(self) and any(
-                    isinstance(self[i], Instr) for i in range(index, len(self))
+    def insert(
+        self, index: SupportsIndex, instr: Union[Instr, SetLineno, TryBegin, TryEnd]
+    ) -> None:
+        self._check_instr(instr)
+        super().insert(index, instr)
+
+    def extend(
+        self, instrs: Iterable[Union[Instr, SetLineno, TryBegin, TryEnd]]
+    ) -> None:
+        instrs = list(instrs)
+        for instr in instrs:
+            self._check_instr(instr)
+        existing_last = self.get_last_non_artificial_instruction()
+        last_new_instr: Optional[Instr] = None
+        for instr in instrs:
+            if isinstance(instr, Instr):
+                if (existing_last is not None and existing_last.has_jump()) or (
+                    last_new_instr is not None and last_new_instr.has_jump()
                 ):
                     raise ValueError(
                         "Only the last instruction of a basic block can be a jump"
                     )
+                last_new_instr = instr
+        super().extend(instrs)
+
+    def __setitem__(self, index, value):
+        if isinstance(index, slice):
+            values = list(value)
+            for instr in values:
+                self._check_instr(instr)
+            super().__setitem__(index, values)
+        else:
+            self._check_instr(value)
+            super().__setitem__(index, value)
 
+    def __iter__(self) -> Iterator[Union[Instr, SetLineno, TryBegin, TryEnd]]:
+        for instr in super().__iter__():
+            if isinstance(instr, Instr) and instr.has_jump():
                 if not isinstance(instr.arg, BasicBlock):
                     raise ValueError(
-                        "Jump target must a BasicBlock, got %s",
-                        type(instr.arg).__name__,
+                        "Jump target must a BasicBlock, got %s"
+                        % type(instr.arg).__name__
                     )
-
-            if isinstance(instr, TryBegin):
+            elif isinstance(instr, TryBegin):
                 if not isinstance(instr.target, BasicBlock):
                     raise ValueError(
-                        "TryBegin target must a BasicBlock, got %s",
-                        type(instr.target).__name__,
+                        "TryBegin target must a BasicBlock, got %s"
+                        % type(instr.target).__name__
                     )
-
             yield instr
 
     @overload
@@ -93,10 +130,9 @@ class BasicBlock(_bytecode._InstrList[Union[Instr, SetLineno, TryBegin, TryEnd]]
         return value
 
     def get_last_non_artificial_instruction(self) -> Optional[Instr]:
-        for instr in reversed(self):
+        for instr in super().__reversed__():
             if isinstance(instr, Instr):
                 return instr
-
         return None
 
     def copy(self: T) -> T:
@@ -130,7 +166,7 @@ class BasicBlock(_bytecode._InstrList[Union[Instr, SetLineno, TryBegin, TryEnd]]
 
         return current_lineno
 
-    def get_jump(self) -> Optional["BasicBlock"]:
+    def get_jump(self) -> Optional[BasicBlock]:
         if not self:
             return None
 
@@ -244,7 +280,7 @@ class _StackSizeComputer:
         self.pending_try_begin = pending_try_begin
         self._current_try_begin = pending_try_begin
 
-    def run(self) -> Generator[Union["_StackSizeComputer", int], int, None]:
+    def run(self) -> Generator[Union[_StackSizeComputer, int], int, None]:
         """Iterate over the block instructions to compute stack usage."""
         # Blocks are not hashable but in this particular context we know we won't be
         # modifying blocks in place so we can safely use their id as hash rather than
@@ -307,7 +343,17 @@ class _StackSizeComputer:
                 # current try begin. However inside the CFG some blocks may
                 # start with a TryEnd relevant only when reaching this block
                 # through a particular jump. So we are lenient here.
-                if instr.entry is not self._current_try_begin:
+                #
+                # We match on the exception handler (the TryBegin target block)
+                # rather than on the TryBegin instance: a single exception region
+                # can be split into several TryBegin copies that share the same
+                # handler (see ``from_bytecode``), and the copy carried over as
+                # ``pending_try_begin`` through a jump is not necessarily the same
+                # instance as the one referenced by this block's leading TryEnd.
+                if (
+                    self._current_try_begin is None
+                    or instr.entry.target is not self._current_try_begin.target
+                ):
                     continue
 
                 # Compute the stack usage of the exception handler
@@ -344,9 +390,11 @@ class _StackSizeComputer:
                     None,
                     # Do not propagate the TryBegin if a final instruction is followed
                     # by a TryEnd.
-                    None
-                    if instr.is_final() and self.block.get_trailing_try_end(i)
-                    else self._current_try_begin,
+                    (
+                        None
+                        if instr.is_final() and self.block.get_trailing_try_end(i)
+                        else self._current_try_begin
+                    ),
                 )
 
                 # Update the maximum used size by the usage implied by the following
@@ -363,8 +411,10 @@ class _StackSizeComputer:
                     # start with a TryEnd relevant only when reaching this block
                     # through a particular jump. So we are lenient here.
                     if (
-                        te := self.block.get_trailing_try_end(i)
-                    ) and te.entry is self._current_try_begin:
+                        (te := self.block.get_trailing_try_end(i))
+                        and self._current_try_begin is not None
+                        and te.entry.target is self._current_try_begin.target
+                    ):
                         assert isinstance(te.entry.target, BasicBlock)
                         yield from self._compute_exception_handler_stack_usage(
                             te.entry.target,
@@ -427,7 +477,7 @@ class _StackSizeComputer:
 
     def _compute_exception_handler_stack_usage(
         self, block: BasicBlock, push_lasti: bool
-    ) -> Generator[Union["_StackSizeComputer", int], int, None]:
+    ) -> Generator[Union[_StackSizeComputer, int], int, None]:
         b_id = id(block)
         if self.minsize < self.common.exception_block_startsize[b_id]:
             block_size = yield _StackSizeComputer(
@@ -447,18 +497,10 @@ class _StackSizeComputer:
     def _is_stacksize_computation_relevant(
         self, block_id: int, fingerprint: Tuple[int, Optional[bool]]
     ) -> bool:
-        if PY311:
-            # The computation is relevant if the block was not visited previously
-            # with the same starting size and exception handler status than the
-            # one in use
-            return fingerprint not in self.common.blocks_startsizes[block_id]
-        else:
-            # The computation is relevant if the block was only visited with smaller
-            # starting sizes than the one in use
-            if sizes := self.common.blocks_startsizes[block_id]:
-                return fingerprint[0] > max(f[0] for f in sizes)
-            else:
-                return True
+        # The computation is relevant if the block was not visited previously
+        # with the same starting size and exception handler status than the
+        # one in use
+        return fingerprint not in self.common.blocks_startsizes[block_id]
 
 
 class ControlFlowGraph(_bytecode.BaseBytecode):
@@ -521,11 +563,10 @@ class ControlFlowGraph(_bytecode.BaseBytecode):
         )
 
         # Starting with Python 3.10, generator and coroutines start with one object
-        # on the stack (None, anything is an error).
+        # on the stack (None, anything else is an error).
         initial_stack_size = 0
         if (
             not PY313  # under 3.13+ RETURN_GENERATOR make this explicit
-            and PY310
             and self.flags
             & (
                 CompilerFlags.GENERATOR
@@ -588,7 +629,6 @@ class ControlFlowGraph(_bytecode.BaseBytecode):
             if compute_exception_stack_depths:
                 for tb in common.try_begins:
                     size = common.exception_block_startsize[id(tb.target)]
-                    assert size >= 0
                     tb.stack_depth = size
 
             return args
@@ -629,7 +669,7 @@ class ControlFlowGraph(_bytecode.BaseBytecode):
                         # argument rather than a Label. This is fine for comparison
                         # purposes which is our sole goal here.
                         c_instr = ConcreteInstr(
-                            instr.name,
+                            instr._name,
                             self.get_block_index(target_block),
                             location=instr.location,
                         )
@@ -748,7 +788,7 @@ class ControlFlowGraph(_bytecode.BaseBytecode):
         return [b for b in self if id(b) not in seen_block_ids]
 
     @staticmethod
-    def from_bytecode(bytecode: _bytecode.Bytecode) -> "ControlFlowGraph":
+    def from_bytecode(bytecode: _bytecode.Bytecode) -> ControlFlowGraph:
         # label => instruction index
         label_to_block_index = {}
         jumps = []
@@ -841,7 +881,7 @@ class ControlFlowGraph(_bytecode.BaseBytecode):
                 # The last instruction is final, if the current instruction is a
                 # TryEnd insert it in the same block and move to the next instruction
                 if last_instr.is_final() and isinstance(instr, TryEnd):
-                    assert active_try_begin
+                    assert active_try_begin is not None
                     nte = instr.copy()
                     nte.entry = try_begins[active_try_begin][-1]
                     old_block.append(nte)
@@ -888,7 +928,6 @@ class ControlFlowGraph(_bytecode.BaseBytecode):
             if isinstance(instr, (Instr, TryBegin, TryEnd)):
                 new = instr.copy()
                 if isinstance(instr, TryBegin):
-                    assert active_try_begin is None
                     active_try_begin = instr
                     try_begin_inserted_in_block = True
                     assert isinstance(new, TryBegin)
@@ -982,9 +1021,7 @@ class ControlFlowGraph(_bytecode.BaseBytecode):
                         # If due to jumps and split TryBegin, we encounter a TryBegin
                         # while we still have a TryBegin ensure they can be fused.
                         if last_try_begin is not None:
-                            cfg_tb, byt_tb = last_try_begin
-                            assert instr.target is cfg_tb.target
-                            assert instr.push_lasti == cfg_tb.push_lasti
+                            _, byt_tb = last_try_begin
                             byt_tb.stack_depth = min(
                                 byt_tb.stack_depth, instr.stack_depth
                             )
@@ -1003,7 +1040,6 @@ class ControlFlowGraph(_bytecode.BaseBytecode):
                                 # If we did not yet compute the required stack depth
                                 # keep the value as UNSET
                                 if entry.stack_depth is UNSET:
-                                    assert instr.stack_depth is UNSET
                                     byt_te.entry.stack_depth = UNSET
                                 else:
                                     byt_te.entry.stack_depth = min(