bytecode 0.16.0__tar.gz → 0.16.1__tar.gz

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

@@ -74,7 +74,7 @@ jobs:
         run: |
           tox
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         if: github.event_name != 'schedule'
         with:
           token: ${{ secrets.CODECOV_TOKEN }}

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: bytecode
-Version: 0.16.0
+Version: 0.16.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>

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

@@ -1,6 +1,13 @@
 ChangeLog
 =========
 
+2025-01-21: Version 0.16.1
+--------------------------
+
+Bugfixes:
+
+- fix flag inference for async code PR #157
+
 
 2024-10-28: Version 0.16.0
 --------------------------

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

@@ -58,7 +58,7 @@ class BasicBlock(_bytecode._InstrList[Union[Instr, SetLineno, TryBegin, TryEnd]]
                     isinstance(self[i], Instr) for i in range(index, len(self))
                 ):
                     raise ValueError(
-                        "Only the last instruction of a basic " "block can be a jump"
+                        "Only the last instruction of a basic block can be a jump"
                     )
 
                 if not isinstance(instr.arg, BasicBlock):

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

@@ -83,7 +83,7 @@ class ConcreteInstr(BaseInstr[int]):
     # For ConcreteInstr the argument is always an integer
     _arg: int
 
-    __slots__ = ("_size", "_extended_args")
+    __slots__ = ("_extended_args", "_size")
 
     def __init__(
         self,
@@ -221,7 +221,7 @@ class ExceptionTableEntry:
     #: before the exception itself (which is pushed as a single value)).
     push_lasti: bool
 
-    __slots__ = ("start_offset", "stop_offset", "target", "stack_depth", "push_lasti")
+    __slots__ = ("push_lasti", "stack_depth", "start_offset", "stop_offset", "target")
 
     def __init__(
         self,

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

@@ -1,11 +1,13 @@
-import opcode
-import sys
+import opcode as _opcode
 from enum import IntFlag
 from typing import Optional, Union
 
 # alias to keep the 'bytecode' variable free
 import bytecode as _bytecode
 
+from .instr import DUAL_ARG_OPCODES, CellVar, FreeVar
+from .utils import PY311, PY312, PY313
+
 
 class CompilerFlags(IntFlag):
     """Possible values of the co_flags attribute of Code object.
@@ -32,14 +34,31 @@ class CompilerFlags(IntFlag):
     # Generator defined in an async def function
     ASYNC_GENERATOR = 0x00200
 
-    # __future__ flags
-    # future flags changed in Python 3.9
-    if sys.version_info < (3, 9):
-        FUTURE_GENERATOR_STOP = 0x80000
-        FUTURE_ANNOTATIONS = 0x100000
-    else:
-        FUTURE_GENERATOR_STOP = 0x800000
-        FUTURE_ANNOTATIONS = 0x1000000
+    FUTURE_GENERATOR_STOP = 0x800000
+    FUTURE_ANNOTATIONS = 0x1000000
+
+
+UNOPTIMIZED_OPCODES = (
+    _opcode.opmap["STORE_NAME"],
+    _opcode.opmap["LOAD_NAME"],
+    _opcode.opmap["DELETE_NAME"],
+)
+
+ASYNC_OPCODES = (
+    _opcode.opmap["GET_AWAITABLE"],
+    _opcode.opmap["GET_AITER"],
+    _opcode.opmap["GET_ANEXT"],
+    _opcode.opmap["BEFORE_ASYNC_WITH"],
+    *((_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
+)
+
+YIELD_VALUE_OPCODE = _opcode.opmap["YIELD_VALUE"]
+GENERATOR_LIKE_OPCODES = (
+    *((_opcode.opmap["YIELD_FROM"],) if not PY311 else ()),  # Removed in 3.11+
+    *((_opcode.opmap["RETURN_GENERATOR"],) if PY311 else ()),  # Added in 3.11+
+)
 
 
 def infer_flags(
@@ -70,8 +89,7 @@ def infer_flags(
         (_bytecode.Bytecode, _bytecode.ConcreteBytecode, _bytecode.ControlFlowGraph),
     ):
         msg = (
-            "Expected a Bytecode, ConcreteBytecode or ControlFlowGraph "
-            "instance not %s"
+            "Expected a Bytecode, ConcreteBytecode or ControlFlowGraph instance not %s"
         )
         raise ValueError(msg % bytecode)
 
@@ -80,26 +98,73 @@ def infer_flags(
         if isinstance(bytecode, _bytecode.ControlFlowGraph)
         else bytecode
     )
-    instr_names = {
-        i.name
-        for i in instructions
-        if not isinstance(
-            i,
+
+    # Iterate over the instructions and inspect the arguments
+    is_concrete = isinstance(bytecode, _bytecode.ConcreteBytecode)
+    optimized = True
+    has_free = False if not is_concrete else bytecode.cellvars and bytecode.freevars
+    known_async = False
+    known_generator = False
+    possible_generator = False
+    instr_iter = iter(instructions)
+    for instr in instr_iter:
+        if isinstance(
+            instr,
             (
                 _bytecode.SetLineno,
                 _bytecode.Label,
                 _bytecode.TryBegin,
                 _bytecode.TryEnd,
             ),
-        )
-    }
+        ):
+            continue
+        opcode = instr.opcode
+        if opcode in UNOPTIMIZED_OPCODES:
+            optimized = False
+        elif opcode in ASYNC_OPCODES:
+            known_async = True
+        elif opcode == YIELD_VALUE_OPCODE:
+            if PY311:
+                while isinstance(
+                    ni := next(instr_iter),
+                    (
+                        _bytecode.SetLineno,
+                        _bytecode.Label,
+                        _bytecode.TryBegin,
+                        _bytecode.TryEnd,
+                    ),
+                ):
+                    pass
+                assert ni.name == "RESUME"
+                if (ni.arg & 3) != 3:
+                    known_generator = True
+                else:
+                    known_async = True
+            else:
+                known_generator = True
+        elif opcode in GENERATOR_LIKE_OPCODES:
+            possible_generator = True
+        elif opcode in _opcode.hasfree:
+            has_free = True
+        elif (
+            not is_concrete
+            and opcode in DUAL_ARG_OPCODES
+            and (isinstance(instr.arg[0], CellVar) or isinstance(instr.arg[1], CellVar))
+        ):
+            has_free = True
+        elif (
+            PY313
+            and opcode in _opcode.haslocal
+            and isinstance(instr.arg, (CellVar, FreeVar))
+        ):
+            has_free = True
 
     # Identify optimized code
-    if not (instr_names & {"STORE_NAME", "LOAD_NAME", "DELETE_NAME"}):
+    if optimized:
         flags |= CompilerFlags.OPTIMIZED
 
     # Check for free variables
-    if not (instr_names & {opcode.opname[i] for i in opcode.hasfree}):
+    if not has_free:
         flags |= CompilerFlags.NOFREE
 
     # Copy flags for which we cannot infer the right value
@@ -110,29 +175,19 @@ def infer_flags(
         | CompilerFlags.NESTED
     )
 
-    sure_generator = instr_names & {"YIELD_VALUE"}
-    maybe_generator = instr_names & {"YIELD_VALUE", "YIELD_FROM", "RETURN_GENERATOR"}
-
-    sure_async = instr_names & {
-        "GET_AWAITABLE",
-        "GET_AITER",
-        "GET_ANEXT",
-        "BEFORE_ASYNC_WITH",
-        "SETUP_ASYNC_WITH",
-        "END_ASYNC_FOR",
-        "ASYNC_GEN_WRAP",  # New in 3.11
-    }
-
     # If performing inference or forcing an async behavior, first inspect
     # the flags since this is the only way to identify iterable coroutines
     if is_async in (None, True):
-        if bytecode.flags & CompilerFlags.COROUTINE:
-            if sure_generator:
+        if (
+            bytecode.flags & CompilerFlags.COROUTINE
+            or bytecode.flags & CompilerFlags.ASYNC_GENERATOR
+        ):
+            if known_generator:
                 flags |= CompilerFlags.ASYNC_GENERATOR
             else:
                 flags |= CompilerFlags.COROUTINE
         elif bytecode.flags & CompilerFlags.ITERABLE_COROUTINE:
-            if sure_async:
+            if known_async:
                 msg = (
                     "The ITERABLE_COROUTINE flag is set but bytecode that"
                     "can only be used in async functions have been "
@@ -141,25 +196,20 @@ def infer_flags(
                 )
                 raise ValueError(msg)
             flags |= CompilerFlags.ITERABLE_COROUTINE
-        elif bytecode.flags & CompilerFlags.ASYNC_GENERATOR:
-            if not sure_generator:
-                flags |= CompilerFlags.COROUTINE
-            else:
-                flags |= CompilerFlags.ASYNC_GENERATOR
 
         # If the code was not asynchronous before determine if it should now be
         # asynchronous based on the opcode and the is_async argument.
         else:
-            if sure_async:
+            if known_async:
                 # YIELD_FROM is not allowed in async generator
-                if sure_generator:
+                if known_generator:
                     flags |= CompilerFlags.ASYNC_GENERATOR
                 else:
                     flags |= CompilerFlags.COROUTINE
 
-            elif maybe_generator:
+            elif known_generator or possible_generator:
                 if is_async:
-                    if sure_generator:
+                    if known_generator:
                         flags |= CompilerFlags.ASYNC_GENERATOR
                     else:
                         flags |= CompilerFlags.COROUTINE
@@ -172,14 +222,14 @@ def infer_flags(
     # If the code should not be asynchronous, check first it is possible and
     # next set the GENERATOR flag if relevant
     else:
-        if sure_async:
+        if known_async:
             raise ValueError(
                 "The is_async argument is False but bytecodes "
                 "that can only be used in async functions have "
                 "been detected."
             )
 
-        if maybe_generator:
+        if known_generator or possible_generator:
             flags |= CompilerFlags.GENERATOR
 
     flags |= bytecode.flags & CompilerFlags.FUTURE_GENERATOR_STOP

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

@@ -269,13 +269,12 @@ class FreeVar(_Variable):
 def _check_arg_int(arg: Any, name: str) -> TypeGuard[int]:
     if not isinstance(arg, int):
         raise TypeError(
-            "operation %s argument must be an int, "
-            "got %s" % (name, type(arg).__name__)
+            "operation %s argument must be an int, got %s" % (name, type(arg).__name__)
         )
 
     if not (0 <= arg <= 2147483647):
         raise ValueError(
-            "operation %s argument must be in " "the range 0..2,147,483,647" % name
+            "operation %s argument must be in the range 0..2,147,483,647" % name
         )
 
     return True
@@ -441,7 +440,7 @@ class InstrLocation:
     #: End column offset at which the instruction corresponds (Python 3.11+ only)
     end_col_offset: Optional[int]
 
-    __slots__ = ["lineno", "end_lineno", "col_offset", "end_col_offset"]
+    __slots__ = ["col_offset", "end_col_offset", "end_lineno", "lineno"]
 
     def __init__(
         self,
@@ -523,7 +522,7 @@ class SetLineno:
 
 
 class TryBegin:
-    __slots__ = ("target", "push_lasti", "stack_depth")
+    __slots__ = ("push_lasti", "stack_depth", "target")
 
     def __init__(
         self,
@@ -556,7 +555,7 @@ A = TypeVar("A", bound=object)
 class BaseInstr(Generic[A]):
     """Abstract instruction."""
 
-    __slots__ = ("_name", "_opcode", "_arg", "_location")
+    __slots__ = ("_arg", "_location", "_name", "_opcode")
 
     # Work around an issue with the default value of arg
     def __init__(
@@ -900,13 +899,9 @@ class Instr(BaseInstr[InstrArg]):
 
         elif opcode in _opcode.hasconst:
             if isinstance(arg, Label):
-                raise ValueError(
-                    "label argument cannot be used " "in %s operation" % name
-                )
+                raise ValueError("label argument cannot be used in %s operation" % name)
             if isinstance(arg, _bytecode.BasicBlock):
-                raise ValueError(
-                    "block argument cannot be used " "in %s operation" % name
-                )
+                raise ValueError("block argument cannot be used in %s operation" % name)
 
         elif opcode in _opcode.hascompare:
             if not isinstance(arg, Compare):

{bytecode-0.16.0 → bytecode-0.16.1}/src/bytecode/version.py

@@ -5,7 +5,7 @@ from collections import namedtuple
 #: A namedtuple of the version info for the current release.
 _version_info = namedtuple("_version_info", "major minor micro status")
 
-parts = "0.16.0".split(".", 3)
+parts = "0.16.1".split(".", 3)
 version_info = _version_info(
     int(parts[0]),
     int(parts[1]),
@@ -16,4 +16,4 @@ version_info = _version_info(
 # Remove everything but the 'version_info' from this module.
 del namedtuple, _version_info, parts
 
-__version__ = "0.16.0"
+__version__ = "0.16.1"

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: bytecode
-Version: 0.16.0
+Version: 0.16.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>

{bytecode-0.16.0 → bytecode-0.16.1}/tests/test_cfg.py

@@ -668,18 +668,12 @@ class BytecodeBlocksFunctionalTests(TestCase):
             )
         elif PY311:
             # jump is relative not absolute
-            expected = (
-                b"|\x05" b"r\x02" b"|\x00" b"}\x05" b"d\x01" b"}\x05" b"|\x05" b"S\x00"
-            )
+            expected = b"|\x05r\x02|\x00}\x05d\x01}\x05|\x05S\x00"
         elif OFFSET_AS_INSTRUCTION:
             # The argument of the jump is divided by 2
-            expected = (
-                b"|\x05" b"r\x04" b"|\x00" b"}\x05" b"d\x01" b"}\x05" b"|\x05" b"S\x00"
-            )
+            expected = b"|\x05r\x04|\x00}\x05d\x01}\x05|\x05S\x00"
         else:
-            expected = (
-                b"|\x05" b"r\x08" b"|\x00" b"}\x05" b"d\x01" b"}\x05" b"|\x05" b"S\x00"
-            )
+            expected = b"|\x05r\x08|\x00}\x05d\x01}\x05|\x05S\x00"
 
         code = bytecode.to_code()
         self.assertEqual(code.co_consts, (None, 3))

{bytecode-0.16.0 → bytecode-0.16.1}/tests/test_flags.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 import sys
 import unittest
+from copy import copy
 
 from bytecode import (
     Bytecode,
@@ -11,10 +12,52 @@ from bytecode import (
 )
 from bytecode.flags import infer_flags
 from bytecode.instr import UNSET, FreeVar, Instr
+from bytecode.utils import PY311, PY312
 
-# Py 3.11
-# - new opcodes could modify inference:
-#   - SEND, ASYNC_GEN_WRAP, RETURN_GENERATOR,
+
+def trivial():
+    pass
+
+
+def _fact(a):
+    def inner():
+        return a
+
+    return inner
+
+
+hasfree = _fact(1)
+
+
+def gen():
+    yield 1
+
+
+async def trivial_async():
+    pass
+
+
+async def async_await(a):
+    await a
+
+
+async def async_with_comprehension():
+    return [await i for i in range(10)]
+
+
+async def async_generator():
+    yield 1
+
+
+FLAG_INFERENCE_TEST_CASES = [
+    trivial,
+    hasfree,
+    gen,
+    trivial_async,
+    async_await,
+    async_with_comprehension,
+    async_generator,
+]
 
 
 class FlagsTests(unittest.TestCase):
@@ -58,16 +101,31 @@ class FlagsTests(unittest.TestCase):
         self.assertFalse(bool(code.flags & CompilerFlags.OPTIMIZED))
         self.assertFalse(bool(code.flags & CompilerFlags.NOFREE))
 
+    def test_function_rountrip(self):
+        for f in FLAG_INFERENCE_TEST_CASES:
+            for cls in (Bytecode, ConcreteBytecode):
+                with self.subTest(f"Testing {f.__name__} with {cls}"):
+                    b = cls.from_code(f.__code__)
+                    existing = copy(b.flags)
+                    b.update_flags()
+                    # NOTE: as far as I can tell NOFREE is not used by CPython anymore
+                    # it shows up nowhere in the interpreter logic and only exist in
+                    # dis and inspect...
+                    self.assertEqual(
+                        existing & ~CompilerFlags.NOFREE,
+                        b.flags & ~CompilerFlags.NOFREE,
+                    )
+
     def test_async_gen_no_flag_is_async_None(self):
         # Test inference in the absence of any flag set on the bytecode
 
         # Infer generator
         code = ConcreteBytecode()
         code.append(
-            ConcreteInstr("YIELD_VALUE", 0)
-            if sys.version_info >= (3, 12)
-            else ConcreteInstr("YIELD_VALUE")
+            ConcreteInstr("YIELD_VALUE", 0) if PY312 else ConcreteInstr("YIELD_VALUE")
         )
+        if PY311:
+            code.append(ConcreteInstr("RESUME", 1))
         code.update_flags()
         self.assertTrue(bool(code.flags & CompilerFlags.GENERATOR))
 
@@ -80,24 +138,22 @@ class FlagsTests(unittest.TestCase):
         self.assertTrue(bool(code.flags & CompilerFlags.COROUTINE))
 
         # Infer coroutine or async generator
-        for i, expected in (
-            ("YIELD_VALUE", CompilerFlags.ASYNC_GENERATOR),
-            ("YIELD_FROM", CompilerFlags.COROUTINE),
+        for i, r, expected in (
+            ("YIELD_VALUE", 1, CompilerFlags.ASYNC_GENERATOR),
+            ("YIELD_VALUE", 2, CompilerFlags.ASYNC_GENERATOR),
+            # YIELD_VALUE is used for normal await flow in Py 3.11+ when followed
+            # by a RESUME whose lowest two bits are set to 3
+            *((("YIELD_VALUE", 3, CompilerFlags.COROUTINE),) if PY311 else ()),
+            ("YIELD_FROM", 0, CompilerFlags.COROUTINE),
         ):
             with self.subTest(i):
-                if sys.version_info >= (3, 11) and i == "YIELD_FROM":
+                if PY311 and i == "YIELD_FROM":
                     self.skipTest("YIELD_FROM does not exist on 3.11")
                 code = ConcreteBytecode()
-                code.append(
-                    ConcreteInstr(
-                        "GET_AWAITABLE", 0 if sys.version_info >= (3, 11) else UNSET
-                    )
-                )
-                code.append(
-                    ConcreteInstr(i, 0)
-                    if sys.version_info >= (3, 12)
-                    else ConcreteInstr(i)
-                )
+                code.append(ConcreteInstr("GET_AWAITABLE", 0 if PY311 else UNSET))
+                code.append(ConcreteInstr(i, 0) if PY312 else ConcreteInstr(i))
+                if PY311:
+                    code.append(ConcreteInstr("RESUME", r))
                 code.update_flags()
                 self.assertTrue(bool(code.flags & expected))
 
@@ -110,21 +166,23 @@ class FlagsTests(unittest.TestCase):
         self.assertTrue(bool(code.flags & CompilerFlags.COROUTINE))
 
         # Infer coroutine or async generator
-        for i, expected in (
-            ("YIELD_VALUE", CompilerFlags.ASYNC_GENERATOR),
-            ("YIELD_FROM", CompilerFlags.COROUTINE),
+        for i, r, expected in (
+            ("YIELD_VALUE", 1, CompilerFlags.ASYNC_GENERATOR),
+            ("YIELD_VALUE", 2, CompilerFlags.ASYNC_GENERATOR),
+            # YIELD_VALUE is used for normal await flow in Py 3.11+ when followed
+            # by a RESUME whose lowest two bits are set to 3
+            *((("YIELD_VALUE", 3, CompilerFlags.COROUTINE),) if PY311 else ()),
+            ("YIELD_FROM", 0, CompilerFlags.COROUTINE),
         ):
             with self.subTest(i):
-                if sys.version_info >= (3, 11) and i == "YIELD_FROM":
+                if PY311 and i == "YIELD_FROM":
                     self.skipTest("YIELD_FROM does not exist on 3.11")
                 code = ConcreteBytecode()
-                code.append(
-                    ConcreteInstr(i, 0)
-                    if sys.version_info >= (3, 12)
-                    else ConcreteInstr(i)
-                )
+                code.append(ConcreteInstr(i, 0) if PY312 else ConcreteInstr(i))
+                if PY311:
+                    code.append(ConcreteInstr("RESUME", r))
                 code.update_flags(is_async=True)
-                self.assertTrue(bool(code.flags & expected))
+                self.assertEqual(code.flags & expected, expected)
 
     def test_async_gen_no_flag_is_async_False(self):
         # Test inference when we request a non-async function
@@ -132,10 +190,10 @@ class FlagsTests(unittest.TestCase):
         # Infer generator
         code = ConcreteBytecode()
         code.append(
-            ConcreteInstr("YIELD_VALUE", 0)
-            if sys.version_info >= (3, 12)
-            else ConcreteInstr("YIELD_VALUE")
+            ConcreteInstr("YIELD_VALUE", 0) if PY312 else ConcreteInstr("YIELD_VALUE")
         )
+        if PY311:
+            code.append(ConcreteInstr("RESUME", 1))
         code.flags = CompilerFlags(CompilerFlags.COROUTINE)
         code.update_flags(is_async=False)
         self.assertTrue(bool(code.flags & CompilerFlags.GENERATOR))
@@ -157,9 +215,11 @@ class FlagsTests(unittest.TestCase):
             code = ConcreteBytecode()
             code.append(
                 ConcreteInstr("YIELD_VALUE", 0)
-                if sys.version_info >= (3, 12)
+                if PY312
                 else ConcreteInstr("YIELD_VALUE")
             )
+            if PY311:
+                code.append(ConcreteInstr("RESUME", 1))
             for f, expected in (
                 (CompilerFlags.COROUTINE, CompilerFlags.ASYNC_GENERATOR),
                 (CompilerFlags.ASYNC_GENERATOR, CompilerFlags.ASYNC_GENERATOR),
@@ -170,7 +230,7 @@ class FlagsTests(unittest.TestCase):
                 self.assertTrue(bool(code.flags & expected))
 
             # Infer coroutine
-            if sys.version_info < (3, 11):
+            if not PY311:
                 code = ConcreteBytecode()
                 code.append(ConcreteInstr("YIELD_FROM"))
                 for f, expected in (
@@ -187,11 +247,7 @@ class FlagsTests(unittest.TestCase):
 
             # Crash on ITERABLE_COROUTINE with async bytecode
             code = ConcreteBytecode()
-            code.append(
-                ConcreteInstr(
-                    "GET_AWAITABLE", 0 if sys.version_info >= (3, 11) else UNSET
-                )
-            )
+            code.append(ConcreteInstr("GET_AWAITABLE", 0 if PY311 else UNSET))
             code.flags = CompilerFlags(CompilerFlags.ITERABLE_COROUTINE)
             with self.assertRaises(ValueError):
                 code.update_flags(is_async=is_async)

{bytecode-0.16.0 → bytecode-0.16.1}/src/bytecode/__init__.py

@@ -1,14 +1,14 @@
 __all__ = [
-    "Label",
-    "Instr",
-    "SetLineno",
+    "BinaryOp",
     "Bytecode",
-    "ConcreteInstr",
+    "Compare",
+    "CompilerFlags",
     "ConcreteBytecode",
+    "ConcreteInstr",
     "ControlFlowGraph",
-    "CompilerFlags",
-    "Compare",
-    "BinaryOp",
+    "Instr",
+    "Label",
+    "SetLineno",
     "__version__",
 ]