@lewin671/python-vm 0.1.0

package/dist/vm/truthy.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTruthy = isTruthy;
+const runtime_types_1 = require("./runtime-types");
+const value_utils_1 = require("./value-utils");
+function isTruthy(value, scope) {
+    if (value === null || value === undefined)
+        return false;
+    if (value instanceof Number)
+        return value.valueOf() !== 0;
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return value !== 0;
+    if (typeof value === 'bigint')
+        return value !== 0n;
+    if (typeof value === 'string')
+        return value.length > 0;
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (value instanceof runtime_types_1.PyDict)
+        return value.size > 0;
+    if (value instanceof Set)
+        return value.size > 0;
+    if (value instanceof runtime_types_1.PyInstance) {
+        const boolAttr = this.findClassAttribute(value.klass, '__bool__');
+        if (boolAttr !== undefined) {
+            const bound = this.getAttribute(value, '__bool__', scope);
+            const result = typeof bound === 'function' ? bound() : bound;
+            if (typeof result !== 'boolean') {
+                throw new runtime_types_1.PyException('TypeError', '__bool__ should return bool');
+            }
+            return result;
+        }
+        const lenAttr = this.findClassAttribute(value.klass, '__len__');
+        if (lenAttr !== undefined) {
+            const bound = this.getAttribute(value, '__len__', scope);
+            const result = typeof bound === 'function' ? bound() : bound;
+            if (!(0, value_utils_1.isNumericLike)(result)) {
+                throw new runtime_types_1.PyException('TypeError', '__len__ should return int');
+            }
+            return (0, value_utils_1.toNumber)(result) !== 0;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=truthy.js.map

package/dist/vm/value-utils.d.ts

@@ -0,0 +1,28 @@
+export declare const isPyNone: (value: any) => boolean;
+export declare const isBigInt: (value: any) => value is bigint;
+export declare const isIntObject: (value: any) => boolean;
+export declare const isFloatObject: (value: any) => boolean;
+export declare const isFloatLike: (value: any) => boolean;
+export declare const isIntLike: (value: any) => boolean;
+export declare const isNumericLike: (value: any) => boolean;
+export declare const toNumber: (value: any) => number;
+export declare const toBigIntValue: (value: any) => bigint;
+export declare const shouldUseBigInt: (left: any, right: any) => boolean;
+export declare const numericEquals: (left: any, right: any) => boolean;
+export declare const numericCompare: (left: any, right: any) => {
+    kind: "float" | "int";
+    left: number | bigint;
+    right: number | bigint;
+} | null;
+export declare const bigIntFloorDiv: (left: bigint, right: bigint) => bigint;
+export declare const pyTypeName: (value: any) => string;
+export declare const pyRepr: (value: any) => string;
+export declare const pyStr: (value: any) => string;
+export declare const isComplex: (value: any) => any;
+export declare const toComplex: (value: any) => any;
+export declare const pythonModulo: (left: any, right: any) => number | bigint | Number;
+export declare const parseStringToken: (tokenValue: string) => {
+    value: string;
+    isFString: boolean;
+};
+//# sourceMappingURL=value-utils.d.ts.map

package/dist/vm/value-utils.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStringToken = exports.pythonModulo = exports.toComplex = exports.isComplex = exports.pyStr = exports.pyRepr = exports.pyTypeName = exports.bigIntFloorDiv = exports.numericCompare = exports.numericEquals = exports.shouldUseBigInt = exports.toBigIntValue = exports.toNumber = exports.isNumericLike = exports.isIntLike = exports.isFloatLike = exports.isFloatObject = exports.isIntObject = exports.isBigInt = exports.isPyNone = void 0;
+const runtime_types_1 = require("./runtime-types");
+const isPyNone = (value) => value === null;
+exports.isPyNone = isPyNone;
+const isBigInt = (value) => typeof value === 'bigint';
+exports.isBigInt = isBigInt;
+const isIntObject = (value) => value instanceof Number && value.__int__ === true;
+exports.isIntObject = isIntObject;
+const isFloatObject = (value) => value instanceof Number && !(0, exports.isIntObject)(value);
+exports.isFloatObject = isFloatObject;
+const isFloatLike = (value) => (0, exports.isFloatObject)(value) || (typeof value === 'number' && !Number.isInteger(value));
+exports.isFloatLike = isFloatLike;
+const isIntLike = (value) => (0, exports.isBigInt)(value) ||
+    value === true ||
+    value === false ||
+    (typeof value === 'number' && Number.isInteger(value)) ||
+    (0, exports.isIntObject)(value);
+exports.isIntLike = isIntLike;
+const isNumericLike = (value) => (0, exports.isBigInt)(value) || typeof value === 'number' || value instanceof Number || typeof value === 'boolean';
+exports.isNumericLike = isNumericLike;
+const toNumber = (value) => {
+    if (value instanceof Number)
+        return value.valueOf();
+    if (typeof value === 'boolean')
+        return value ? 1 : 0;
+    if (typeof value === 'bigint')
+        return Number(value);
+    return value;
+};
+exports.toNumber = toNumber;
+const toBigIntValue = (value) => {
+    if (typeof value === 'bigint')
+        return value;
+    if (value instanceof Number)
+        return BigInt(Math.trunc(value.valueOf()));
+    if (typeof value === 'number')
+        return BigInt(value);
+    return BigInt(value);
+};
+exports.toBigIntValue = toBigIntValue;
+const shouldUseBigInt = (left, right) => ((0, exports.isBigInt)(left) || (0, exports.isBigInt)(right)) && !(0, exports.isFloatLike)(left) && !(0, exports.isFloatLike)(right);
+exports.shouldUseBigInt = shouldUseBigInt;
+const numericEquals = (left, right) => {
+    if ((0, exports.isNumericLike)(left) && (0, exports.isNumericLike)(right)) {
+        if ((0, exports.isFloatLike)(left) || (0, exports.isFloatLike)(right)) {
+            const leftNum = (0, exports.toNumber)(left);
+            const rightNum = (0, exports.toNumber)(right);
+            return !Number.isNaN(leftNum) && !Number.isNaN(rightNum) && leftNum === rightNum;
+        }
+        return (0, exports.toBigIntValue)(left) === (0, exports.toBigIntValue)(right);
+    }
+    return left === right;
+};
+exports.numericEquals = numericEquals;
+const numericCompare = (left, right) => {
+    if (!(0, exports.isNumericLike)(left) || !(0, exports.isNumericLike)(right))
+        return null;
+    if ((0, exports.isFloatLike)(left) || (0, exports.isFloatLike)(right)) {
+        return { kind: 'float', left: (0, exports.toNumber)(left), right: (0, exports.toNumber)(right) };
+    }
+    return { kind: 'int', left: (0, exports.toBigIntValue)(left), right: (0, exports.toBigIntValue)(right) };
+};
+exports.numericCompare = numericCompare;
+const bigIntFloorDiv = (left, right) => {
+    const quotient = left / right;
+    if (left % right === 0n)
+        return quotient;
+    if ((left < 0n) !== (right < 0n))
+        return quotient - 1n;
+    return quotient;
+};
+exports.bigIntFloorDiv = bigIntFloorDiv;
+const pyTypeName = (value) => {
+    if (value === null)
+        return 'NoneType';
+    if ((0, exports.isBigInt)(value))
+        return 'int';
+    if ((0, exports.isIntObject)(value))
+        return 'int';
+    if (value instanceof Number)
+        return 'float';
+    if (typeof value === 'boolean')
+        return 'bool';
+    if (typeof value === 'number')
+        return Number.isInteger(value) ? 'int' : 'float';
+    if (typeof value === 'string')
+        return 'str';
+    if (Array.isArray(value))
+        return value.__tuple__ ? 'tuple' : 'list';
+    if (value instanceof Set)
+        return 'set';
+    if (value instanceof runtime_types_1.PyDict)
+        return 'dict';
+    if (value instanceof runtime_types_1.PyFunction)
+        return 'function';
+    if (value instanceof runtime_types_1.PyClass)
+        return 'type';
+    if (value instanceof runtime_types_1.PyInstance)
+        return value.klass.name;
+    return typeof value;
+};
+exports.pyTypeName = pyTypeName;
+const pyRepr = (value) => {
+    if (value === null)
+        return 'None';
+    if (value instanceof Number) {
+        const num = value.valueOf();
+        if (Number.isNaN(num))
+            return 'nan';
+        if (num === Infinity)
+            return 'inf';
+        if (num === -Infinity)
+            return '-inf';
+        if ((0, exports.isIntObject)(value))
+            return String(num);
+        if (Object.is(num, -0))
+            return '-0.0';
+        return Number.isInteger(num) ? `${num}.0` : String(num);
+    }
+    if (typeof value === 'boolean')
+        return value ? 'True' : 'False';
+    if (typeof value === 'number')
+        return Number.isNaN(value) ? 'nan' : String(value);
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (value && value.__complex__) {
+        const sign = value.im >= 0 ? '+' : '-';
+        const imag = Math.abs(value.im);
+        return `(${value.re}${sign}${imag}j)`;
+    }
+    if (typeof value === 'string')
+        return `'${value.replace(/'/g, "\\'")}'`;
+    if (Array.isArray(value)) {
+        const items = value.map((v) => (0, exports.pyRepr)(v)).join(', ');
+        if (value.__tuple__) {
+            if (value.length === 1)
+                return `(${items},)`;
+            return `(${items})`;
+        }
+        return `[${items}]`;
+    }
+    if (value instanceof Set) {
+        const items = Array.from(value.values()).map((v) => (0, exports.pyRepr)(v)).join(', ');
+        return `{${items}}`;
+    }
+    if (value instanceof runtime_types_1.PyDict) {
+        const items = Array.from(value.entries()).map(([k, v]) => `${(0, exports.pyRepr)(k)}: ${(0, exports.pyRepr)(v)}`).join(', ');
+        return `{${items}}`;
+    }
+    if (value instanceof runtime_types_1.PyFunction)
+        return `<function ${value.name}>`;
+    if (value instanceof runtime_types_1.PyClass)
+        return `<class '${value.name}'>`;
+    if (value instanceof runtime_types_1.PyInstance)
+        return `<${value.klass.name} object>`;
+    return String(value);
+};
+exports.pyRepr = pyRepr;
+const pyStr = (value) => {
+    if (typeof value === 'string')
+        return value;
+    if (value && value.__complex__)
+        return (0, exports.pyRepr)(value);
+    if (value && value.__typeName__)
+        return `<class '${value.__typeName__}'>`;
+    if (value instanceof runtime_types_1.PyException)
+        return value.message;
+    return (0, exports.pyRepr)(value);
+};
+exports.pyStr = pyStr;
+const isComplex = (value) => value && value.__complex__;
+exports.isComplex = isComplex;
+const toComplex = (value) => {
+    if ((0, exports.isComplex)(value))
+        return value;
+    if ((0, exports.isNumericLike)(value))
+        return { __complex__: true, re: (0, exports.toNumber)(value), im: 0 };
+    return { __complex__: true, re: 0, im: 0 };
+};
+exports.toComplex = toComplex;
+const pythonModulo = (left, right) => {
+    if ((0, exports.shouldUseBigInt)(left, right)) {
+        const leftNum = (0, exports.toBigIntValue)(left);
+        const rightNum = (0, exports.toBigIntValue)(right);
+        if (rightNum === 0n)
+            throw new runtime_types_1.PyException('ZeroDivisionError', 'division by zero');
+        const remainder = leftNum % rightNum;
+        const adjust = remainder !== 0n && (leftNum < 0n) !== (rightNum < 0n);
+        const quotient = leftNum / rightNum - (adjust ? 1n : 0n);
+        return leftNum - quotient * rightNum;
+    }
+    const leftNum = (0, exports.toNumber)(left);
+    const rightNum = (0, exports.toNumber)(right);
+    if (rightNum === 0)
+        throw new runtime_types_1.PyException('ZeroDivisionError', 'division by zero');
+    const quotient = Math.floor(leftNum / rightNum);
+    const result = leftNum - quotient * rightNum;
+    if ((0, exports.isFloatObject)(left) || (0, exports.isFloatObject)(right)) {
+        return new Number(result);
+    }
+    return result;
+};
+exports.pythonModulo = pythonModulo;
+const parseStringToken = (tokenValue) => {
+    let raw = tokenValue;
+    let isFString = false;
+    if (raw.startsWith('f') || raw.startsWith('F')) {
+        isFString = true;
+        raw = raw.slice(1);
+    }
+    const quote = raw[0];
+    if (raw.startsWith(quote.repeat(3))) {
+        const inner = raw.slice(3, -3);
+        return { value: inner, isFString };
+    }
+    const inner = raw.slice(1, -1);
+    return {
+        value: inner.replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\"/g, '"').replace(/\\'/g, "'"),
+        isFString,
+    };
+};
+exports.parseStringToken = parseStringToken;
+//# sourceMappingURL=value-utils.js.map

package/dist/vm/vm.d.ts

@@ -0,0 +1,56 @@
+import { installBuiltins } from './builtins';
+import { callFunction, containsYield, evaluateComprehension, expressionHasYield, generateComprehension } from './callable';
+import { execute, executeBlock, executeBlockGenerator, executeStatementGenerator, iterableToArray, matchPattern, matchValueEquals, applyBindings } from './execution';
+import { evaluateExpressionGenerator } from './expression-generator';
+import { createAsyncioModule, importModule, loadModuleFromFile, resolveModulePath } from './imports';
+import { applyFormatSpec, applyWidth, contains, evaluateExpression, evaluateExpressionString, executeExpressionInline, splitFormatSpec } from './expressions';
+import { assignTarget, deleteTarget, executeStatement, toIterableArray } from './statements';
+import { applyBinary, computeSliceBounds, computeSliceIndices, findClassAttribute, formatPercent, getAttribute, getSubscript, normalizeSliceStep, setAttribute } from './operations';
+import { isTruthy } from './truthy';
+export declare class VirtualMachine {
+    moduleCache: Map<string, any>;
+    moduleSearchPaths: string[];
+    constructor(moduleSearchPaths?: string[]);
+    execute: typeof execute;
+    installBuiltins: typeof installBuiltins;
+    importModule: typeof importModule;
+    createAsyncioModule: typeof createAsyncioModule;
+    loadModuleFromFile: typeof loadModuleFromFile;
+    resolveModulePath: typeof resolveModulePath;
+    executeBlock: typeof executeBlock;
+    iterableToArray: typeof iterableToArray;
+    matchValueEquals: typeof matchValueEquals;
+    matchPattern: typeof matchPattern;
+    applyBindings: typeof applyBindings;
+    executeBlockGenerator: typeof executeBlockGenerator;
+    executeStatementGenerator: typeof executeStatementGenerator;
+    evaluateExpressionGenerator: typeof evaluateExpressionGenerator;
+    executeStatement: typeof executeStatement;
+    assignTarget: typeof assignTarget;
+    toIterableArray: typeof toIterableArray;
+    deleteTarget: typeof deleteTarget;
+    evaluateExpression: typeof evaluateExpression;
+    evaluateExpressionString: typeof evaluateExpressionString;
+    executeExpressionInline: typeof executeExpressionInline;
+    applyFormatSpec: typeof applyFormatSpec;
+    splitFormatSpec: typeof splitFormatSpec;
+    applyWidth: typeof applyWidth;
+    contains: typeof contains;
+    isTruthy: typeof isTruthy;
+    applyBinary: typeof applyBinary;
+    formatPercent: typeof formatPercent;
+    getSubscript: typeof getSubscript;
+    computeSliceBounds: typeof computeSliceBounds;
+    computeSliceIndices: typeof computeSliceIndices;
+    normalizeSliceStep: typeof normalizeSliceStep;
+    getAttribute: typeof getAttribute;
+    setAttribute: typeof setAttribute;
+    findClassAttribute: typeof findClassAttribute;
+    callFunction: typeof callFunction;
+    containsYield: typeof containsYield;
+    evaluateComprehension: typeof evaluateComprehension;
+    generateComprehension: typeof generateComprehension;
+    expressionHasYield: typeof expressionHasYield;
+}
+export * from './runtime-types';
+//# sourceMappingURL=vm.d.ts.map

package/dist/vm/vm.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualMachine = void 0;
+const builtins_1 = require("./builtins");
+const callable_1 = require("./callable");
+const execution_1 = require("./execution");
+const expression_generator_1 = require("./expression-generator");
+const imports_1 = require("./imports");
+const expressions_1 = require("./expressions");
+const statements_1 = require("./statements");
+const operations_1 = require("./operations");
+const truthy_1 = require("./truthy");
+class VirtualMachine {
+    constructor(moduleSearchPaths = [process.cwd()]) {
+        this.moduleCache = new Map();
+        this.execute = execution_1.execute;
+        this.installBuiltins = builtins_1.installBuiltins;
+        this.importModule = imports_1.importModule;
+        this.createAsyncioModule = imports_1.createAsyncioModule;
+        this.loadModuleFromFile = imports_1.loadModuleFromFile;
+        this.resolveModulePath = imports_1.resolveModulePath;
+        this.executeBlock = execution_1.executeBlock;
+        this.iterableToArray = execution_1.iterableToArray;
+        this.matchValueEquals = execution_1.matchValueEquals;
+        this.matchPattern = execution_1.matchPattern;
+        this.applyBindings = execution_1.applyBindings;
+        this.executeBlockGenerator = execution_1.executeBlockGenerator;
+        this.executeStatementGenerator = execution_1.executeStatementGenerator;
+        this.evaluateExpressionGenerator = expression_generator_1.evaluateExpressionGenerator;
+        this.executeStatement = statements_1.executeStatement;
+        this.assignTarget = statements_1.assignTarget;
+        this.toIterableArray = statements_1.toIterableArray;
+        this.deleteTarget = statements_1.deleteTarget;
+        this.evaluateExpression = expressions_1.evaluateExpression;
+        this.evaluateExpressionString = expressions_1.evaluateExpressionString;
+        this.executeExpressionInline = expressions_1.executeExpressionInline;
+        this.applyFormatSpec = expressions_1.applyFormatSpec;
+        this.splitFormatSpec = expressions_1.splitFormatSpec;
+        this.applyWidth = expressions_1.applyWidth;
+        this.contains = expressions_1.contains;
+        this.isTruthy = truthy_1.isTruthy;
+        this.applyBinary = operations_1.applyBinary;
+        this.formatPercent = operations_1.formatPercent;
+        this.getSubscript = operations_1.getSubscript;
+        this.computeSliceBounds = operations_1.computeSliceBounds;
+        this.computeSliceIndices = operations_1.computeSliceIndices;
+        this.normalizeSliceStep = operations_1.normalizeSliceStep;
+        this.getAttribute = operations_1.getAttribute;
+        this.setAttribute = operations_1.setAttribute;
+        this.findClassAttribute = operations_1.findClassAttribute;
+        this.callFunction = callable_1.callFunction;
+        this.containsYield = callable_1.containsYield;
+        this.evaluateComprehension = callable_1.evaluateComprehension;
+        this.generateComprehension = callable_1.generateComprehension;
+        this.expressionHasYield = callable_1.expressionHasYield;
+        this.moduleSearchPaths = moduleSearchPaths;
+    }
+}
+exports.VirtualMachine = VirtualMachine;
+__exportStar(require("./runtime-types"), exports);
+//# sourceMappingURL=vm.js.map

package/examples/assert_testing.py

@@ -0,0 +1,38 @@
+# Assert 语句进行简单测试
+def test_addition():
+    assert 2 + 2 == 4, "Addition failed"
+    assert 1 + 1 == 2
+    print("Addition tests passed")
+
+def test_string():
+    assert "hello".upper() == "HELLO"
+    assert "hello" == "hello"
+    print("String tests passed")
+
+def test_list():
+    lst = [1, 2, 3]
+    assert len(lst) == 3
+    assert 2 in lst
+    assert 4 not in lst
+    print("List tests passed")
+
+def test_comparison():
+    assert 5 > 3
+    assert 2 < 5
+    assert 5 >= 5
+    print("Comparison tests passed")
+
+# 运行测试
+test_addition()
+test_string()
+test_list()
+test_comparison()
+
+print("\nAll tests passed!")
+
+# 测试失败的示例
+print("\nTesting failure case:")
+try:
+    assert 1 == 2, "This assertion will fail"
+except AssertionError as e:
+    print(f"Caught AssertionError: {e}")

package/examples/big_int_precision.py

@@ -0,0 +1,2 @@
+# Exposes JS-number precision loss if integers are not BigInt-backed.
+print(10**20 + 1 == 10**20)

package/examples/boolean_logic.py

@@ -0,0 +1,35 @@
+# 布尔类型和逻辑运算
+x = True
+y = False
+
+print("x and y:", x and y)
+print("x or y:", x or y)
+print("not x:", not x)
+
+# 比较运算
+a = 10
+b = 20
+
+print(f"{a} == {b}:", a == b)
+print(f"{a} != {b}:", a != b)
+print(f"{a} < {b}:", a < b)
+print(f"{a} > {b}:", a > b)
+print(f"{a} <= {b}:", a <= b)
+print(f"{a} >= {b}:", a >= b)
+
+# 链式比较
+c = 15
+print(f"{a} < {c} < {b}:", a < c < b)
+
+# 成员运算符
+numbers = [1, 2, 3, 4, 5]
+print("3 in numbers:", 3 in numbers)
+print("6 not in numbers:", 6 not in numbers)
+
+# 布尔条件
+if (x or (a < b and not y)):
+    print("Complex condition is true")
+
+# 三元运算符
+result = "positive" if a > 0 else "non-positive"
+print(f"a is {result}")

package/examples/break_continue.py

@@ -0,0 +1,43 @@
+# Break 和 Continue 语句
+print("Break example:")
+for i in range(10):
+    if i == 5:
+        break
+    print(i, end=" ")
+print()
+
+print("\nContinue example:")
+for i in range(10):
+    if i % 2 == 0:
+        continue
+    print(i, end=" ")
+print()
+
+# 嵌套循环中的 break
+print("\nNested loop with break:")
+for i in range(3):
+    for j in range(3):
+        if j == 1:
+            break
+        print(f"({i}, {j})", end=" ")
+print()
+
+# While 循环中的 break 和 continue
+print("\nWhile with break and continue:")
+count = 0
+while count < 10:
+    count += 1
+    if count == 3:
+        continue
+    if count == 8:
+        break
+    print(count, end=" ")
+print()
+
+# Pass 语句
+print("\nPass statement:")
+for i in range(3):
+    if i == 1:
+        pass  # 占位符
+    else:
+        print(f"i = {i}")

package/examples/classes_objects.py

@@ -0,0 +1,43 @@
+# 类定义和对象
+class Dog:
+    species = "Canis familiaris"
+    
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+    
+    def bark(self):
+        return f"{self.name} says: Woof!"
+    
+    def birthday(self):
+        self.age += 1
+        return f"{self.name} is now {self.age} years old"
+
+# 创建对象
+dog1 = Dog("Rex", 3)
+dog2 = Dog("Buddy", 5)
+
+print(dog1.bark())
+print(dog2.bark())
+
+# 访问属性
+print(f"{dog1.name} is {dog1.age} years old")
+
+# 调用方法
+print(dog1.birthday())
+print(f"Species: {dog1.species}")
+
+# 继承
+class Animal:
+    def __init__(self, name):
+        self.name = name
+    
+    def speak(self):
+        return f"{self.name} makes a sound"
+
+class Cat(Animal):
+    def speak(self):
+        return f"{self.name} says: Meow!"
+
+cat = Cat("Whiskers")
+print(cat.speak())

package/examples/compiler_killer_async.py

@@ -0,0 +1,6 @@
+import asyncio
+
+async def main():
+    return 3
+
+print(asyncio.run(main()))

package/examples/compiler_killer_bigint.py

@@ -0,0 +1,3 @@
+# Exploit: bool is a subclass of int; indexing should treat True as 1
+arr = [10, 20]
+print(arr[True])

package/examples/compiler_killer_bool_int_dict_key.py

@@ -0,0 +1,5 @@
+d = {1: "int", True: "bool"}
+print(len(d))
+print(d[1])
+print(d[True])
+print(list(d.keys()))

package/examples/compiler_killer_bool_len.py

@@ -0,0 +1,9 @@
+class Trick:
+    def __bool__(self):
+        return False
+    def __len__(self):
+        return 1
+
+t = Trick()
+print(bool(t))
+print("truthy" if t else "falsy")

package/examples/compiler_killer_floor_division.py

@@ -0,0 +1,4 @@
+x = -3
+print(x // 2)
+print(x % 2)
+print((x // 2) * 2 + (x % 2))

package/examples/compiler_killer_is_identity.py

@@ -0,0 +1,3 @@
+a = int("257")
+b = int("257")
+print(a is b)

package/examples/compiler_killer_list_sort_return.py

@@ -0,0 +1,3 @@
+a = [3, 1]
+print(a.sort())
+print(a)

package/examples/compiler_killer_match.py

@@ -0,0 +1,13 @@
+def classify(value):
+    match value:
+        case 0 | 1:
+            return "small"
+        case [a, b]:
+            return a + b
+        case _:
+            return "other"
+
+
+print(classify([2, 3]))
+print(classify(1))
+print(classify("x"))

package/examples/compiler_killer_negative_repeat.py

@@ -0,0 +1,3 @@
+print('start')
+print('a' * -1)
+print('end')

package/examples/compiler_killer_negative_zero_repr.py

@@ -0,0 +1,3 @@
+# CPython preserves the sign of negative zero in float formatting.
+print(-0.0)
+print(float("-0.0"))

package/examples/compiler_killer_rounding.py

@@ -0,0 +1,4 @@
+# Adversarial: Python round uses bankers rounding (ties to even)
+
+print(round(2.5))
+print(round(3.5))