bytecode 0.16.1__tar.gz → 0.17.0__tar.gz

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

@@ -20,7 +20,7 @@ jobs:
     name: Lint code
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
@@ -42,8 +42,6 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - python-version: "3.8"
-            toxenv: py38
           - python-version: "3.9"
             toxenv: py39
           - python-version: "3.10"
@@ -54,8 +52,10 @@ jobs:
             toxenv: py312
           - python-version: "3.13"
             toxenv: py313
+          - python-version: "3.14-dev"
+            toxenv: py314
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Get history and tags for SCM versioning to work
         run: |
           git fetch --prune --unshallow

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

@@ -19,7 +19,7 @@ jobs:
     name: Docs building
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - name: Get history and tags for SCM versioning to work
         run: |
           git fetch --prune --unshallow

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

@@ -21,10 +21,10 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 0
 

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

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
       - name: Get history and tags for SCM versioning to work
         run: |
           git fetch --prune --unshallow
@@ -43,7 +43,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
       - name: Get history and tags for SCM versioning to work
         run: |
           git fetch --prune --unshallow
@@ -72,20 +72,20 @@ jobs:
     if: github.event_name == 'push'
     needs: [build_wheel, build_sdist]
     runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/kiwisolver
+    permissions:
+      id-token: write
     steps:
       - name: Download all the dists
-        uses: actions/download-artifact@v4.1.8
+        uses: actions/download-artifact@v5.0.0
         with:
           pattern: cibw-*
           path: dist
           merge-multiple: true
 
       - uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          user: __token__
-          password: ${{ secrets.pypi_password }}
-          # To test:
-          # repository_url: https://test.pypi.org/legacy/
 
   github-release:
     name: >-
@@ -101,15 +101,14 @@ jobs:
 
     steps:
     - name: Download all the dists
-      uses: actions/download-artifact@v4.1.8
+      uses: actions/download-artifact@v5.0.0
       with:
         pattern: cibw-*
         path: dist
         merge-multiple: true
     - name: Sign the dists with Sigstore
-      uses: sigstore/gh-action-sigstore-python@v2.1.0
+      uses: sigstore/gh-action-sigstore-python@v3.0.1
       with:
-        password: ${{ secrets.pypi_password }}
         inputs: >-
           ./dist/*.tar.gz
           ./dist/*.whl

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: bytecode
-Version: 0.16.1
+Version: 0.17.0
 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,17 +36,18 @@ 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.8
 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.8
+Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: COPYING
 Requires-Dist: typing_extensions; python_version < "3.10"
+Dynamic: license-file
 
 ********
 bytecode

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

@@ -1,6 +1,40 @@
 ChangeLog
 =========
 
+03-09-2025: Version 0.17.0
+--------------------------
+
+New features:
+
+- Add support for Python 3.14 PR #166
+
+  Support for Python 3.14, comes with a number of changes reflecting changes in
+  CPython bytecode itself:
+
+  - introduced an enum for BINARY_OP argument which now supports subscribe.
+    When disassembling the enum is always used, when creating bytecode from
+    scratch integer values are coerced into the right enum member.
+  - support BUILD_TEMPLATE, BUILD_INTERPOLATION, LOAD_SMALL_INT, LOAD_FAST_BORROW
+    and LOAD_FAST_BORROW_LOAD_FAST_BORROW
+  - LOAD_COMMON_CONSTANT, LOAD_SPECIAL whose argument is described using dedicated
+    enums CommonConstant, SpecialMethod
+  - CONVERT_VALUE (FORMAT_VALUE in Python < 3.13) now use the FormatValue enum.
+    When disassembling the enum is always used, when creating bytecode from
+    scratch integer values are coerced into the right enum member.
+
+Bugfixes:
+
+- properly set the next_block attribute of the new block created by
+  ControlFlowGraph.split_block. PR #170
+
+2025-04-14: Version 0.16.2
+--------------------------
+
+Bugfixes:
+
+- fix ControlFlowGraph dead block detection by accounting for fall-through
+  edges. PR #161
+
 2025-01-21: Version 0.16.1
 --------------------------
 

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

@@ -2,7 +2,7 @@
   name = "bytecode"
   description = "Python module to generate and modify bytecode"
   readme = "README.rst"
-  requires-python = ">=3.8"
+  requires-python = ">=3.9"
   license = { file = "COPYING" }
   authors = [{ name = "Victor Stinner", email = "victor.stinner@gmail.com" }]
   maintainers = [{ name = "Matthieu C. Dartiailh", email = "m.dartiailh@gmail.com" }]
@@ -13,12 +13,12 @@
     "Natural Language :: English",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
     "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",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Software Development :: Libraries :: Python Modules",
   ]
   dependencies = ["typing_extensions;python_version<'3.10'"]
@@ -36,6 +36,18 @@
   requires      = ["setuptools>=61.2", "wheel", "setuptools_scm[toml]>=3.4.3"]
   build-backend = "setuptools.build_meta"
 
+[dependency-groups]
+  dev = [
+    "mypy>=1.16.1",
+    "pytest>=8",
+    "pytest-cov>=6",
+    "ruff>=0.12.0",
+  ]
+  test = [
+    "pytest>=8",
+    "pytest-cov",
+  ]
+
 [tool.setuptools_scm]
   write_to = "src/bytecode/version.py"
   write_to_template = """
@@ -74,7 +86,7 @@ __version__ = "{version}"
       extra-standard-library = ["opcode"]
 
     [tool.ruff.lint.mccabe]
-      max-complexity = 42
+      max-complexity = 43
 
 [tool.mypy]
   follow_imports  = "normal"

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

@@ -710,6 +710,7 @@ class ControlFlowGraph(_bytecode.BaseBytecode):
         del block[index:]
 
         block2 = BasicBlock(instructions)
+        block2.next_block = block.next_block
         block.next_block = block2
 
         for block in self[block_index + 1 :]:
@@ -731,12 +732,18 @@ class ControlFlowGraph(_bytecode.BaseBytecode):
             if id(block) in seen_block_ids:
                 continue
             seen_block_ids.add(id(block))
+            fall_through = True
             for i in block:
-                if isinstance(i, Instr) and isinstance(i.arg, BasicBlock):
-                    stack.append(i.arg)
+                if isinstance(i, Instr):
+                    if isinstance(i.arg, BasicBlock):
+                        stack.append(i.arg)
+                    if i.is_final():
+                        fall_through = False
                 elif isinstance(i, TryBegin):
                     assert isinstance(i.target, BasicBlock)
                     stack.append(i.target)
+            if fall_through and block.next_block:
+                stack.append(block.next_block)
 
         return [b for b in self if id(b) not in seen_block_ids]
 
@@ -865,9 +872,7 @@ class ControlFlowGraph(_bytecode.BaseBytecode):
                     #   the new one since the blocks are disconnected.
                     if last_instr.is_final() and temp:
                         old_block.append(TryEnd(try_begins[active_try_begin][-1]))
-                        new_tb = TryBegin(
-                            active_try_begin.target, active_try_begin.push_lasti
-                        )
+                        new_tb = active_try_begin.copy()
                         block.append(new_tb)
                         # Add this new TryBegin to the map to properly update
                         # the target.

{bytecode-0.16.1 → bytecode-0.17.0}/src/bytecode/concrete.py

@@ -26,18 +26,25 @@ import bytecode as _bytecode
 from bytecode.flags import CompilerFlags
 from bytecode.instr import (
     _UNSET,
+    BINARY_OPS,
     BITFLAG2_OPCODES,
     BITFLAG_OPCODES,
+    COMMON_CONSTANT_OPS,
     DUAL_ARG_OPCODES,
     DUAL_ARG_OPCODES_SINGLE_OPS,
+    FORMAT_VALUE_OPS,
     INTRINSIC,
     INTRINSIC_1OP,
     INTRINSIC_2OP,
     PLACEHOLDER_LABEL,
+    SPECIAL_OPS,
     UNSET,
     BaseInstr,
+    BinaryOp,
     CellVar,
+    CommonConstant,
     Compare,
+    FormatValue,
     FreeVar,
     Instr,
     InstrArg,
@@ -46,6 +53,7 @@ from bytecode.instr import (
     Intrinsic2Op,
     Label,
     SetLineno,
+    SpecialMethod,
     TryBegin,
     TryEnd,
     _check_arg_int,
@@ -1056,7 +1064,10 @@ class ConcreteBytecode(_bytecode._BaseBytecodeList[Union[ConcreteInstr, SetLinen
                         arg = locals_lookup[c_arg]
                 elif opcode in _opcode.hasname:
                     if opcode in BITFLAG_OPCODES:
-                        arg = (bool(c_arg & 1), self.names[c_arg >> 1])
+                        arg = (
+                            bool(c_arg & 1),
+                            self.names[c_arg >> 1],
+                        )
                     elif opcode in BITFLAG2_OPCODES:
                         arg = (bool(c_arg & 1), bool(c_arg & 2), self.names[c_arg >> 2])
                     else:
@@ -1082,6 +1093,20 @@ class ConcreteBytecode(_bytecode._BaseBytecodeList[Union[ConcreteInstr, SetLinen
                     arg = Intrinsic1Op(c_arg)
                 elif opcode in INTRINSIC_2OP:
                     arg = Intrinsic2Op(c_arg)
+                elif opcode in BINARY_OPS:
+                    arg = BinaryOp(c_arg)
+                elif opcode in COMMON_CONSTANT_OPS:
+                    arg = CommonConstant(c_arg)
+                elif opcode in SPECIAL_OPS:
+                    arg = SpecialMethod(c_arg)
+                elif opcode in FORMAT_VALUE_OPS:
+                    if opcode in BITFLAG_OPCODES:
+                        arg = (
+                            bool(c_arg & 1),
+                            FormatValue(c_arg >> 1),
+                        )
+                    else:
+                        arg = FormatValue(c_arg)
                 else:
                     arg = c_arg
 
@@ -1143,7 +1168,7 @@ class ConcreteBytecode(_bytecode._BaseBytecodeList[Union[ConcreteInstr, SetLinen
 
 
 class _ConvertBytecodeToConcrete:
-    # XXX document attributes
+    # FIXME document attributes
 
     #: Default number of passes of compute_jumps() before giving up.  Refer to
     #: assemble_jump_offsets() in compile.c for background.
@@ -1316,9 +1341,13 @@ class _ConvertBytecodeToConcrete:
                         isinstance(arg, tuple)
                         and len(arg) == 2
                         and isinstance(arg[0], bool)
-                        and isinstance(arg[1], str)
                     ), arg
-                    index = self.add(self.names, arg[1])
+                    if isinstance(arg[1], str):
+                        index = self.add(self.names, arg[1])
+                    elif isinstance(arg, FormatValue):
+                        index = int(arg)
+                    else:
+                        assert False, arg  # noqa
                     c_arg = int(arg[0]) + (index << 1)
                 elif opcode in BITFLAG2_OPCODES:
                     assert (

{bytecode-0.16.1 → bytecode-0.17.0}/src/bytecode/flags.py

@@ -6,7 +6,7 @@ from typing import Optional, Union
 import bytecode as _bytecode
 
 from .instr import DUAL_ARG_OPCODES, CellVar, FreeVar
-from .utils import PY311, PY312, PY313
+from .utils import PY311, PY312, PY313, PY314
 
 
 class CompilerFlags(IntFlag):
@@ -48,7 +48,7 @@ ASYNC_OPCODES = (
     _opcode.opmap["GET_AWAITABLE"],
     _opcode.opmap["GET_AITER"],
     _opcode.opmap["GET_ANEXT"],
-    _opcode.opmap["BEFORE_ASYNC_WITH"],
+    *((_opcode.opmap["BEFORE_ASYNC_WITH"],) if not PY314 else ()),  # Removed in 3.14+
     *((_opcode.opmap["SETUP_ASYNC_WITH"],) if not PY311 else ()),  # Removed in 3.11+
     _opcode.opmap["END_ASYNC_FOR"],
     *((_opcode.opmap["ASYNC_GEN_WRAP"],) if PY311 and not PY312 else ()),  # New in 3.11

{bytecode-0.16.1 → bytecode-0.17.0}/src/bytecode/instr.py

@@ -13,7 +13,7 @@ except ImportError:
     from typing_extensions import TypeGuard  # type: ignore
 
 import bytecode as _bytecode
-from bytecode.utils import PY311, PY312, PY313
+from bytecode.utils import PY311, PY312, PY313, PY314
 
 # --- Instruction argument tools and
 
@@ -22,20 +22,48 @@ MIN_INSTRUMENTED_OPCODE = getattr(_opcode, "MIN_INSTRUMENTED_OPCODE", 256)
 # Instructions relying on a bit to modify its behavior.
 # The lowest bit is used to encode custom behavior.
 BITFLAG_OPCODES = (
-    (_opcode.opmap["LOAD_GLOBAL"], _opcode.opmap["LOAD_ATTR"])
-    if PY312
-    else (_opcode.opmap["LOAD_GLOBAL"],)
-    if PY311
-    else ()
+    (
+        _opcode.opmap["BUILD_INTERPOLATION"],
+        _opcode.opmap["LOAD_GLOBAL"],
+        _opcode.opmap["LOAD_ATTR"],
+    )
+    if PY314
+    else (
+        (_opcode.opmap["LOAD_GLOBAL"], _opcode.opmap["LOAD_ATTR"])
+        if PY312
+        else ((_opcode.opmap["LOAD_GLOBAL"],) if PY311 else ())
+    )
 )
 
 BITFLAG2_OPCODES = (_opcode.opmap["LOAD_SUPER_ATTR"],) if PY312 else ()
 
+# Binary op opcode which has a dedicated arg
+BINARY_OPS = (_opcode.opmap["BINARY_OP"],) if PY311 else ()
+
 # Intrinsic related opcodes
 INTRINSIC_1OP = (_opcode.opmap["CALL_INTRINSIC_1"],) if PY312 else ()
 INTRINSIC_2OP = (_opcode.opmap["CALL_INTRINSIC_2"],) if PY312 else ()
 INTRINSIC = INTRINSIC_1OP + INTRINSIC_2OP
 
+# Small integer related opcode
+SMALL_INT_OPS = (_opcode.opmap["LOAD_SMALL_INT"],) if PY314 else ()
+
+# Special method loading related opcodes
+SPECIAL_OPS = (_opcode.opmap["LOAD_SPECIAL"],) if PY314 else ()
+
+# Common constant loading related opcodes
+COMMON_CONSTANT_OPS = (_opcode.opmap["LOAD_COMMON_CONSTANT"],) if PY314 else ()
+
+# Value formatting related opcodes (only handle CONVERT_VALUE and BUILD_INTERPOLATION)
+FORMAT_VALUE_OPS = (
+    (
+        _opcode.opmap["CONVERT_VALUE"],
+        _opcode.opmap["BUILD_INTERPOLATION"],
+    )
+    if PY314
+    else ((_opcode.opmap["CONVERT_VALUE"],) if PY313 else ())
+)
+
 HASJABS = () if PY313 else _opcode.hasjabs
 if sys.version_info >= (3, 13):
     HASJREL = _opcode.hasjump
@@ -51,6 +79,11 @@ if PY313:
         _opcode.opmap["STORE_FAST_LOAD_FAST"],
         _opcode.opmap["STORE_FAST_STORE_FAST"],
     )
+    if PY314:
+        DUAL_ARG_OPCODES = (
+            *DUAL_ARG_OPCODES,
+            _opcode.opmap["LOAD_FAST_BORROW_LOAD_FAST_BORROW"],
+        )
     DUAL_ARG_OPCODES_SINGLE_OPS = {
         _opcode.opmap["LOAD_FAST_LOAD_FAST"]: ("LOAD_FAST", "LOAD_FAST"),
         _opcode.opmap["STORE_FAST_LOAD_FAST"]: ("STORE_FAST", "LOAD_FAST"),
@@ -129,6 +162,8 @@ class BinaryOp(enum.IntEnum):
     INPLACE_SUBTRACT = 23
     INPLACE_TRUE_DIVIDE = 24
     INPLACE_XOR = 25
+    if PY314:
+        SUBSCR = 26
 
 
 @enum.unique
@@ -156,6 +191,34 @@ class Intrinsic2Op(enum.IntEnum):
     INTRINSIC_SET_FUNCTION_TYPE_PARAMS = 4
 
 
+@enum.unique
+class FormatValue(enum.IntEnum):
+    STR = 1
+    REPR = 2
+    ASCII = 3
+
+
+@enum.unique
+class SpecialMethod(enum.IntEnum):
+    """Special method names used with LOAD_SPECIAL"""
+
+    ENTER = 0
+    EXIT = 1
+    AENTER = 2
+    AEXIT = 3
+
+
+@enum.unique
+class CommonConstant(enum.IntEnum):
+    """Common constants names used with LOAD_COMMON_CONSTANT"""
+
+    ASSERTION_ERROR = 0
+    NOT_IMPLEMENTED_ERROR = 1
+    BUILTIN_TUPLE = 2
+    BUILTIN_ALL = 3
+    BUILTIN_ANY = 4
+
+
 # This make type checking happy but means it won't catch attempt to manipulate an unset
 # statically. We would need guard on object attribute narrowed down through methods
 class _UNSET(int):
@@ -336,15 +399,15 @@ STATIC_STACK_EFFECTS: Dict[str, Tuple[int, int]] = {
     "CHECK_EXC_MATCH": (-2, 2),  # (TOS1, TOS) -> (TOS1, bool)
     "CHECK_EG_MATCH": (-2, 2),  # (TOS, TOS1) -> non-matched, matched or TOS1, None)
     "PREP_RERAISE_STAR": (-2, 1),  # (TOS1, TOS) -> new exception group)
-    **{k: (-1, 1) for k in (o for o in _opcode.opmap if (o.startswith("UNARY_")))},
-    **{
-        k: (-2, 1)
-        for k in (
+    **dict.fromkeys((o for o in _opcode.opmap if o.startswith("UNARY_")), (-1, 1)),
+    **dict.fromkeys(
+        (
             o
             for o in _opcode.opmap
-            if (o.startswith("BINARY_") or o.startswith("INPLACE_"))
-        )
-    },
+            if o.startswith("BINARY_") or o.startswith("INPLACE_")
+        ),
+        (-2, 1),
+    ),
     # Python 3.12 changes not covered by dis.stack_effect
     "BINARY_SLICE": (-3, 1),
     # "STORE_SLICE" handled by dis.stack_effect
@@ -357,6 +420,7 @@ STATIC_STACK_EFFECTS: Dict[str, Tuple[int, int]] = {
     "FORMAT_SIMPLE": (-1, 1),  # new in 3.13
     "FORMAT_SPEC": (-2, 1),  # new in 3.13
     "TO_BOOL": (-1, 1),  # new in 3.13
+    "BUILD_TEMPLATE": (-2, 1),  # new in 3.14
 }
 
 
@@ -385,6 +449,7 @@ DYNAMIC_STACK_EFFECTS: Dict[
     "FORMAT_VALUE": lambda effect, arg, jump: (effect - 1, 1),
     # FOR_ITER needs TOS to be an iterator, hence a prerequisite of 1 on the stack
     "FOR_ITER": lambda effect, arg, jump: (effect, 0) if jump else (-1, 2),
+    "BUILD_INTERPOLATION": lambda effect, arg, jump: (-(2 + (arg & 1)), 1),
     **{
         # Instr(UNPACK_* , n) pops 1 and pushes n
         k: lambda effect, arg, jump: (-1, effect + 1)
@@ -660,6 +725,7 @@ class BaseInstr(Generic[A]):
             arg = None
         # 3.11 where LOAD_GLOBAL arg encode whether or we push a null
         # 3.12 does the same for LOAD_ATTR
+        # 3.14 does this for BUILD_INTERPOLATION
         elif self._opcode in BITFLAG_OPCODES and isinstance(self._arg, tuple):
             assert len(self._arg) == 2
             arg = self._arg[0]
@@ -802,8 +868,15 @@ InstrArg = Union[
     FreeVar,
     "_bytecode.BasicBlock",
     Compare,
+    FormatValue,
+    BinaryOp,
+    Intrinsic1Op,
+    Intrinsic2Op,
+    CommonConstant,
+    SpecialMethod,
     Tuple[bool, str],
     Tuple[bool, bool, str],
+    Tuple[bool, FormatValue],
     Tuple[Union[str, CellVar, FreeVar], Union[str, CellVar, FreeVar]],
 ]
 
@@ -817,7 +890,7 @@ class Instr(BaseInstr[InstrArg]):
             arg = const_key(arg)
         return (self._location, self._name, arg)
 
-    def _check_arg(self, name: str, opcode: int, arg: InstrArg) -> None:
+    def _check_arg(self, name: str, opcode: int, arg: InstrArg) -> None:  # noqa: C901
         if name == "EXTENDED_ARG":
             raise ValueError(
                 "only concrete instruction can contain EXTENDED_ARG, "
@@ -854,7 +927,7 @@ class Instr(BaseInstr[InstrArg]):
                     and isinstance(arg[1], str)
                 ):
                     raise TypeError(
-                        "operation %s argument must be a tuple[bool, str], "
+                        "operation %s argument must be a tuple[bool, str | FormatValue], "
                         "got %s (value=%s)" % (name, type(arg).__name__, str(arg))
                     )
 
@@ -910,6 +983,37 @@ class Instr(BaseInstr[InstrArg]):
                     "Compare, got %s" % (name, type(arg).__name__)
                 )
 
+        elif opcode in BINARY_OPS:
+            if not isinstance(arg, BinaryOp):
+                if isinstance(arg, int):
+                    try:
+                        arg = BinaryOp(arg)
+                    except Exception as e:
+                        raise TypeError(
+                            "operation %s argument type must be "
+                            "coercible to BinaryOp, got %s" % (name, type(arg).__name__)
+                        ) from e
+                else:
+                    raise TypeError(
+                        "operation %s argument type must be "
+                        "BinaryOp, got %s" % (name, type(arg).__name__)
+                    )
+
+        # We do not enforce constant immortality since which constants are
+        # immortal may differ between recompilation and execution.
+
+        elif opcode in SMALL_INT_OPS:
+            if not isinstance(arg, int):
+                raise TypeError(
+                    "operation %s argument type must be "
+                    "int, got %s" % (name, type(arg).__name__)
+                )
+            if arg < 0 or arg > 255:
+                raise ValueError(
+                    "operation %s argument type must be an "
+                    "int between 0 and 255, got %s" % (name, arg)
+                )
+
         elif opcode in INTRINSIC_1OP:
             if not isinstance(arg, Intrinsic1Op):
                 raise TypeError(
@@ -924,5 +1028,45 @@ class Instr(BaseInstr[InstrArg]):
                     "Intrinsic2Op, got %s" % (name, type(arg).__name__)
                 )
 
+        elif opcode in SPECIAL_OPS:
+            if not isinstance(arg, SpecialMethod):
+                raise TypeError(
+                    "operation %s argument type must be "
+                    "SpecialMethod, got %s" % (name, type(arg).__name__)
+                )
+        elif opcode in COMMON_CONSTANT_OPS:
+            if not isinstance(arg, CommonConstant):
+                raise TypeError(
+                    "operation %s argument type must be "
+                    "CommonConstant, got %s" % (name, type(arg).__name__)
+                )
+
+        elif opcode in FORMAT_VALUE_OPS:
+            if opcode in BITFLAG_OPCODES:
+                if not (
+                    isinstance(arg, tuple)
+                    and len(arg) == 2
+                    and isinstance(arg[0], bool)
+                    and isinstance(arg[1], FormatValue)
+                ):
+                    raise TypeError(
+                        "operation %s argument must be a tuple[bool, FormatValue], "
+                        "got %s (value=%s)" % (name, type(arg).__name__, str(arg))
+                    )
+            elif not isinstance(arg, FormatValue):
+                if isinstance(arg, int):
+                    try:
+                        arg = FormatValue(arg)
+                    except Exception as e:
+                        raise TypeError(
+                            "operation %s argument must be a FormatValue] "
+                            "got %s (value=%s)" % (name, type(arg).__name__, str(arg))
+                        ) from e
+                else:
+                    raise TypeError(
+                        "operation %s argument must be a FormatValue] "
+                        "got %s (value=%s)" % (name, type(arg).__name__, str(arg))
+                    )
+
         elif opcode_has_argument(opcode):
             _check_arg_int(arg, name)

{bytecode-0.16.1 → bytecode-0.17.0}/src/bytecode/utils.py

@@ -5,3 +5,4 @@ PY310: Final[bool] = sys.version_info >= (3, 10)
 PY311: Final[bool] = sys.version_info >= (3, 11)
 PY312: Final[bool] = sys.version_info >= (3, 12)
 PY313: Final[bool] = sys.version_info >= (3, 13)
+PY314: Final[bool] = sys.version_info >= (3, 14)