Python 3.13 Support Draft

requirements-dev.txt

@@ -2,3 +2,4 @@ nose
 flake8
 six
 pytest
+setuptools

test_unit/test_modules.py

@@ -0,0 +1,38 @@
+import sys
+import dis
+import unittest
+import xdis.std as xdis
+from xdis.version_info import version_tuple_to_str
+
+
+class TestModules(unittest.TestCase):
+    def test_basic(self):
+        # test all ops match
+        if hasattr(sys, "version_info"):
+            print(f"Testing Python Version : {version_tuple_to_str()}")
+        try:
+            self.assertEqual(dis.opname, xdis.opname)
+        except AssertionError as ae:
+            if len(dis.opname) != len(xdis.opname):
+                print("Opname table length mismatch between dis and xdis")
+                ae.add_note("OPNAME TABLE LENGTH MISMATCH, LONGER TABLE WILL BE TRUNCATED")
+            for index, (dop, xop) in enumerate(zip(dis.opname, xdis.opname)):
+                if dop != xop:
+                    print("-"*20)
+                    print(f"Mismatch at op {index}")
+                    print(f"dis opname  : {dop}")
+                    print(f"xdis opname : {xop}")
+            raise ae
+
+        # test "has.." tables
+        xmod = xdis.get_opcode_module()
+        attrs = (attr for attr in dir(dis) if attr.startswith("has"))
+        for attr in attrs:
+            try:
+                self.assertEqual(sorted(getattr(dis, attr)), sorted(getattr(xmod, attr)))
+            except AssertionError as ae:
+                ae.add_note(f"Mismatch 'has' table : {attr}")
+                raise ae
+
+if __name__ == "__main__":
+    unittest.main()

xdis/__init__.py

@@ -40,6 +40,7 @@
     Code38,
     Code310,
     Code311,
+    Code313,
     codeType2Portable,
 )
 from xdis.codetype.base import code_has_star_arg, code_has_star_star_arg, iscode
@@ -183,6 +184,7 @@
     "Code3",
     "Code310",
     "Code311",
+    "Code313",
     "Code38",
     "code_has_star_star_arg",
     "code_has_star_arg",

xdis/bin/pydisasm.py

@@ -52,8 +52,8 @@ def main(format, show_source: bool, files):
     the Python interpreter used to run this program. For example, you can disassemble Python 3.6.9
     bytecode from Python 2.7.15 and vice versa.
     """
-    if not ((2, 7) <= PYTHON_VERSION_TRIPLE < (3, 13)):
-        mess = "This code works on 3.6 to 3.12; you have %s."
+    if not ((2, 7) <= PYTHON_VERSION_TRIPLE < (3, 14)):
+        mess = "This code works on 3.6 to 3.13; you have %s."
         if (2, 4) <= PYTHON_VERSION_TRIPLE <= (2, 7):
             mess += " Code that works for %s can be found in the python-2.4 branch\n"
         elif (3, 1) <= PYTHON_VERSION_TRIPLE <= (3, 2):

xdis/bytecode.py

@@ -341,7 +341,14 @@ def get_instructions_bytes(
                 argval = get_jump_val(arg, opc.python_version)
                 argrepr = "to " + repr(argval)
             elif op in opc.LOCAL_OPS:
-                if opc.version_tuple >= (3, 11):
+                if opc.version_tuple >= (3, 13) and opc.opname[op] in ("LOAD_FAST_LOAD_FAST", "STORE_FAST_LOAD_FAST", "STORE_FAST_STORE_FAST"):
+                    arg1 = arg >> 4
+                    arg2 = arg & 15
+                    argval1, argrepr1 = _get_name_info(arg1, (varnames or tuple()) + (cells or tuple()))
+                    argval2, argrepr2 = _get_name_info(arg2, (varnames or tuple()) + (cells or tuple()))
+                    argval = argval1, argval2
+                    argrepr = argrepr1 + ", " + argrepr2
+                elif opc.version_tuple >= (3, 11):
                     argval, argrepr = _get_name_info(
                         arg, (varnames or tuple()) + (cells or tuple())
                     )
@@ -355,11 +362,13 @@ def get_instructions_bytes(
                 else:
                     argval, argrepr = _get_name_info(arg, cells)
             elif op in opc.COMPARE_OPS:
-                argval = (
-                    opc.cmp_op[arg >> 4]
-                    if opc.python_version >= (3, 12)
-                    else opc.cmp_op[arg]
-                )
+                if opc.python_version >= (3,13):
+                    # The fifth-lowest bit of the oparg now indicates a forced conversion to bool.
+                    argval = (opc.cmp_op[arg >> 5])
+                elif opc.python_version >= (3,12):
+                    argval = (opc.cmp_op[arg >> 4])
+                else:
+                    argval = (opc.cmp_op[arg])
                 argrepr = argval
             elif op in opc.NARGS_OPS:
                 opname = opc.opname[op]

xdis/codetype/__init__.py

@@ -28,6 +28,7 @@
 from xdis.codetype.code38 import Code38
 from xdis.codetype.code310 import Code310
 from xdis.codetype.code311 import Code311, Code311FieldNames
+from xdis.codetype.code313 import Code313
 from xdis.version_info import PYTHON_VERSION_TRIPLE
 
 
@@ -100,7 +101,7 @@ def codeType2Portable(code, version_tuple=PYTHON_VERSION_TRIPLE):
                 co_firstlineno=code.co_firstlineno,
                 co_linetable=line_table,
             )
-        else:  # version tuple >= 3, 11
+        elif version_tuple[:2] < (3,13):  # version tuple >= 3, 11
             return Code311(
                 co_argcount=code.co_argcount,
                 co_posonlyargcount=code.co_posonlyargcount,
@@ -121,6 +122,27 @@ def codeType2Portable(code, version_tuple=PYTHON_VERSION_TRIPLE):
                 co_linetable=line_table,
                 co_exceptiontable=code.co_exceptiontable,
             )
+        else:
+            return Code313(
+                co_argcount=code.co_argcount,
+                co_posonlyargcount=code.co_posonlyargcount,
+                co_kwonlyargcount=code.co_kwonlyargcount,
+                co_nlocals=code.co_nlocals,
+                co_stacksize=code.co_stacksize,
+                co_flags=code.co_flags,
+                co_consts=code.co_consts,
+                co_code=code.co_code,
+                co_names=code.co_names,
+                co_varnames=code.co_varnames,
+                co_freevars=code.co_freevars,
+                co_cellvars=code.co_cellvars,
+                co_filename=code.co_filename,
+                co_name=code.co_name,
+                co_qualname=code.co_qualname,
+                co_firstlineno=code.co_firstlineno,
+                co_linetable=line_table,
+                co_exceptiontable=code.co_exceptiontable,
+            )
     elif version_tuple > (2, 0):
         # 2.0 .. 2.7
         return Code2(
@@ -187,9 +209,11 @@ def portableCodeType(version_tuple=PYTHON_VERSION_TRIPLE):
         elif version_tuple[:2] == (3, 10):
             # 3.10
             return Code310
-        else:
+        elif version_tuple[:2] < (3,13):
             # 3.11 ...
             return Code311
+        else:
+            return Code313
     elif version_tuple > (2, 0):
         # 2.0 .. 2.7
         return Code2