qairt-visualizer 0.5.1__py3-none-win_amd64.whl → 0.7.0__py3-none-win_amd64.whl

qairt_visualizer/core/ui/dist/browser/{assets/netron_plugin/source/python.js → python.js}

@@ -6,7 +6,9 @@ const python = {};
 python.Execution = class {
 
     constructor(sources) {
+        /* eslint-disable consistent-this */
         const self = this;
+        /* eslint-enable consistent-this */
         const execution = self;
         this._sources = sources || new Map();
         this._events = new Map();
@@ -124,7 +126,7 @@ python.Execution = class {
         const operator = this.register('operator');
         this.register('_codecs');
         this.register('argparse');
-        this._enum = this.register('enum');
+        this.enum = this.register('enum');
         this.register('collections');
         const copy = this.register('copy');
         this.register('copy_reg');
@@ -167,6 +169,7 @@ python.Execution = class {
         const torch = this.register('torch');
         this.torch = torch;
         const torchvision = this.register('torchvision');
+        const torchao = this.register('torchao');
         this.register('torch.storage');
         this.register('torch.nn.parameter');
         this.register('torch.ops');
@@ -653,7 +656,7 @@ python.Execution = class {
                 const position = this._position();
                 const body = [];
                 while (!this._tokenizer.match('eof')) {
-                    const statement = this._statement();
+                    const statement = this._parseStatement();
                     if (statement) {
                         body.push(statement);
                         continue;
@@ -670,7 +673,7 @@ python.Execution = class {
                 this._mark(node, position);
                 return node;
             }
-            _suite() {
+            _parseSuite() {
                 const body = [];
                 let statement = null;
                 if (this._tokenizer.eat('\n')) {
@@ -679,7 +682,7 @@ python.Execution = class {
                             if (this._tokenizer.eat(';')) {
                                 continue;
                             }
-                            statement = this._statement();
+                            statement = this._parseStatement();
                             if (statement) {
                                 body.push(statement);
                                 continue;
@@ -698,7 +701,7 @@ python.Execution = class {
                         if (this._tokenizer.eat(';')) {
                             continue;
                         }
-                        statement = this._statement();
+                        statement = this._parseStatement();
                         if (statement) {
                             body.push(statement);
                             continue;
@@ -709,7 +712,7 @@ python.Execution = class {
                 }
                 return body;
             }
-            _statement() {
+            _parseStatement() {
                 let node = null;
                 let position = this._position();
                 if (this._eat('id', 'break')) {
@@ -721,30 +724,30 @@ python.Execution = class {
                     return this._mark(node, position);
                 }
                 if (this._eat('id', 'return')) {
-                    const value = this._expression(-1, [], true);
+                    const value = this._parseExpression(-1, [], true);
                     const node = new ast.Return(value);
                     return this._mark(node, position);
                 }
                 if (this._eat('id', 'raise')) {
-                    let exc = this._expression(-1, ['from']);
+                    let exc = this._parseExpression(-1, ['from']);
                     let cause = null;
                     if (this._tokenizer.eat('id', 'from')) {
-                        cause = this._expression();
+                        cause = this._parseExpression();
                     } else if (this._tokenizer.eat(',')) {
                         exc = [exc];
-                        exc.push(this._expression());
+                        exc.push(this._parseExpression());
                         if (this._tokenizer.eat(',')) {
-                            exc.push(this._expression());
+                            exc.push(this._parseExpression());
                         }
                     }
                     node = new ast.Raise(exc, cause);
                     return this._mark(node, position);
                 }
                 if (this._eat('id', 'assert')) {
-                    const test = this._expression(-1, [',']);
+                    const test = this._parseExpression(-1, [',']);
                     let msg = null;
                     if (this._tokenizer.eat(',')) {
-                        msg = this._expression();
+                        msg = this._parseExpression();
                     }
                     node = new ast.Assert(test, msg);
                     return this._mark(node, position);
@@ -752,7 +755,7 @@ python.Execution = class {
                 if (this._eat('id', 'global')) {
                     const names = [];
                     do {
-                        const name = this._name(true);
+                        const name = this._parseName(true);
                         names.push(name.id);
                     }
                     while (this._tokenizer.eat(','));
@@ -762,7 +765,7 @@ python.Execution = class {
                 if (this._eat('id', 'nonlocal')) {
                     const names = [];
                     do {
-                        const name = this._name(true);
+                        const name = this._parseName(true);
                         names.push(name.id);
                     }
                     while (this._tokenizer.eat(','));
@@ -772,10 +775,10 @@ python.Execution = class {
                 if (this._eat('id', 'import')) {
                     const names = [];
                     do {
-                        const name = this._dottedName();
+                        const name = this._parseDottedName();
                         let asname = null;
                         if (this._tokenizer.eat('id', 'as')) {
-                            asname = this._name(true).id;
+                            asname = this._parseName(true).id;
                         }
                         const node = new ast.alias(name, asname);
                         names.push(node);
@@ -791,15 +794,15 @@ python.Execution = class {
                         this._eat(dots.type);
                         level = Array.from(dots.type).length;
                     }
-                    const module = this._dottedName();
+                    const module = this._parseDottedName();
                     this._tokenizer.expect('id', 'import');
                     const names = [];
                     const close = this._tokenizer.eat('(');
                     do {
-                        const name = this._name(true).id;
+                        const name = this._parseName(true).id;
                         let asname = null;
                         if (this._tokenizer.eat('id', 'as')) {
-                            asname = this._name(true).id;
+                            asname = this._parseName(true).id;
                         }
                         const node = new ast.alias(name, asname);
                         names.push(node);
@@ -814,14 +817,14 @@ python.Execution = class {
                 const decorator_list = this._decorator();
                 position = this._position();
                 if (this._eat('id', 'class')) {
-                    const name = this._name(true);
+                    const name = this._parseName(true);
                     const bases = [];
                     if (this._tokenizer.eat('(')) {
                         while (!this._tokenizer.eat(')')) {
                             if (this._tokenizer.eat('\n')) {
                                 continue;
                             }
-                            const expression = this._expression(-1, [], false);
+                            const expression = this._parseExpression(-1, [], false);
                             if (expression === null) {
                                 throw new python.Error(`Expected expression ${this._location()}`);
                             }
@@ -834,7 +837,7 @@ python.Execution = class {
                         }
                     }
                     this._tokenizer.expect(':');
-                    const body = this._suite();
+                    const body = this._parseSuite();
                     const node = new ast.ClassDef(name.id, bases, null, body, decorator_list, null);
                     return this._mark(node, position);
                 }
@@ -846,15 +849,15 @@ python.Execution = class {
                     throw new python.Error(`Expected 'def', 'with' or 'for' ${this._location()}`);
                 }
                 if (this._eat('id', 'def')) {
-                    const name = this._name(true);
+                    const name = this._parseName(true);
                     this._tokenizer.expect('(');
-                    const args = this._arguments(')');
+                    const args = this._parseArguments(')');
                     let returns = null;
                     if (this._tokenizer.eat('->')) {
-                        returns = this._type();
+                        returns = this._parseType();
                     }
                     this._tokenizer.expect(':');
-                    const body = this._suite();
+                    const body = this._parseSuite();
                     const node = new ast.FunctionDef(name.id, args, body, decorator_list, returns, null, null);
                     if (async) {
                         node.async = async;
@@ -865,39 +868,39 @@ python.Execution = class {
                     throw new python.Error('Unexpected decorator.');
                 }
                 if (this._eat('id', 'del')) {
-                    const targets = this._expression(-1, [], true);
+                    const targets = this._parseExpression(-1, [], true);
                     node = new ast.Del(targets);
                     return this._mark(node, position);
                 }
                 if (this._eat('id', 'if')) {
-                    const test = this._expression();
+                    const test = this._parseExpression();
                     this._tokenizer.expect(':');
-                    const body = this._suite();
+                    const body = this._parseSuite();
                     const node = new ast.If(test, body);
                     let current = node;
                     this._tokenizer.eat('\n');
                     while (this._tokenizer.eat('id', 'elif')) {
-                        const test = this._expression();
+                        const test = this._parseExpression();
                         this._tokenizer.expect(':');
-                        const body = this._suite();
+                        const body = this._parseSuite();
                         current.orelse = new ast.If(test, body);
                         current = current.orelse;
                         this._tokenizer.eat('\n');
                     }
                     if (this._tokenizer.eat('id', 'else')) {
                         this._tokenizer.expect(':');
-                        current.orelse = this._suite();
+                        current.orelse = this._parseSuite();
                     }
                     return this._mark(node, position);
                 }
                 if (this._eat('id', 'while')) {
-                    const test = this._expression();
+                    const test = this._parseExpression();
                     this._tokenizer.expect(':');
-                    const body = this._suite();
+                    const body = this._parseSuite();
                     let orelse = null;
                     if (this._tokenizer.eat('id', 'else')) {
                         this._tokenizer.expect(':');
-                        orelse = this._suite();
+                        orelse = this._parseSuite();
                     }
                     const node = new ast.While(test, body, orelse);
                     return this._mark(node, position);
@@ -907,7 +910,7 @@ python.Execution = class {
                     return this._mark(node, position);
                 }
                 if (this._eat('id', 'for')) {
-                    let target = this._expression(-1, ['in']);
+                    let target = this._parseExpression(-1, ['in']);
                     while (this._tokenizer.eat(',')) {
                         if (target instanceof ast.Tuple === false) {
                             target = new ast.Tuple([target]);
@@ -916,10 +919,10 @@ python.Execution = class {
                             target.elts.push({});
                             break;
                         }
-                        target.elts.push(this._expression(-1, ['in']));
+                        target.elts.push(this._parseExpression(-1, ['in']));
                     }
                     this._tokenizer.expect('id', 'in');
-                    let iter = this._expression();
+                    let iter = this._parseExpression();
                     while (this._tokenizer.eat(',')) {
                         if (iter.type !== 'tuple') {
                             iter = new ast.Tuple([iter]);
@@ -928,14 +931,14 @@ python.Execution = class {
                             iter.elts.push({});
                             break;
                         }
-                        iter.elts.push(this._expression(-1, ['in']));
+                        iter.elts.push(this._parseExpression(-1, ['in']));
                     }
                     this._tokenizer.expect(':');
-                    const body = this._suite();
+                    const body = this._parseSuite();
                     let orelse = null;
                     if (this._tokenizer.eat('id', 'else')) {
                         this._tokenizer.expect(':');
-                        orelse = this._suite();
+                        orelse = this._parseSuite();
                     }
                     const node = new ast.For(target, iter, body, orelse);
                     return this._mark(node, position);
@@ -943,17 +946,17 @@ python.Execution = class {
                 if (this._eat('id', 'with')) {
                     const items = [];
                     do {
-                        const context_expr = this._expression();
+                        const context_expr = this._parseExpression();
                         let optional_vars = null;
                         if (this._tokenizer.eat('id', 'as')) {
-                            optional_vars = this._expression();
+                            optional_vars = this._parseExpression();
                         }
                         const node = new ast.withitem(context_expr, optional_vars);
                         items.push(node);
                     }
                     while (this._tokenizer.eat(','));
                     this._tokenizer.expect(':');
-                    const body = this._suite();
+                    const body = this._parseSuite();
                     const node = new ast.With(items, body, null);
                     if (async) {
                         node.async = async;
@@ -962,40 +965,40 @@ python.Execution = class {
                 }
                 if (this._eat('id', 'try')) {
                     this._tokenizer.expect(':');
-                    const body = this._suite();
+                    const body = this._parseSuite();
                     const handlers = [];
                     let orelse = null;
                     let finalbody = null;
                     while (this._tokenizer.match('id', 'except')) {
                         this._tokenizer.expect('id', 'except');
-                        const type = this._expression();
-                        const name = this._tokenizer.eat('id', 'as') ? this._expression() : null;
+                        const type = this._parseExpression();
+                        const name = this._tokenizer.eat('id', 'as') ? this._parseExpression() : null;
                         this._tokenizer.expect(':');
-                        const body = this._suite();
+                        const body = this._parseSuite();
                         const except = new ast.ExceptHandler(type, name, body);
                         handlers.push(except);
                     }
                     if (this._tokenizer.match('id', 'else')) {
                         this._tokenizer.expect('id', 'else');
                         this._tokenizer.expect(':');
-                        orelse = this._suite();
+                        orelse = this._parseSuite();
                     }
                     if (this._tokenizer.match('id', 'finally')) {
                         this._tokenizer.expect('id', 'finally');
                         this._tokenizer.expect(':');
-                        finalbody = this._suite();
+                        finalbody = this._parseSuite();
                     }
                     const node = new ast.Try(body, handlers, orelse, finalbody);
                     return this._mark(node, position);
                 }
-                const expr = this._expression(-1, [], true);
+                const expr = this._parseExpression(-1, [], true);
                 if (expr) {
                     if (expr instanceof ast.Name && this._tokenizer.eat(':')) {
                         const position = this._position();
-                        const annotation = this._expression(-1, ['=']);
+                        const annotation = this._parseExpression(-1, ['=']);
                         let value = null;
                         if (this._tokenizer.eat('=')) {
-                            value = this._expression();
+                            value = this._parseExpression();
                         }
                         node = new ast.AnnAssign(expr, annotation, value, expr instanceof ast.Name);
                         return this._mark(node, position);
@@ -1033,7 +1036,7 @@ python.Execution = class {
                 }
                 return null;
             }
-            _expression(minPrecedence, terminal, tuple) {
+            _parseExpression(minPrecedence, terminal, tuple) {
                 minPrecedence = minPrecedence || -1;
                 const terminalSet = new Set(terminal);
                 const stack = [];
@@ -1073,7 +1076,7 @@ python.Execution = class {
                                 }
                                 if (op) {
                                     const left = stack.pop();
-                                    const right = this._expression(precedence, terminal, tuple === true ? true : false);
+                                    const right = this._parseExpression(precedence, terminal, tuple === true);
                                     node = new ast.BinOp(left, op, right);
                                 } else {
                                     switch (token.value) {
@@ -1090,14 +1093,14 @@ python.Execution = class {
                                         default: break;
                                     }
                                     const left = stack.pop();
-                                    const comparator = this._expression(precedence, terminal, tuple === true ? true : false);
+                                    const comparator = this._parseExpression(precedence, ['for', 'if'], tuple === true);
                                     node = new ast.Compare(left, [op], [comparator]);
                                 }
                             } else if (token.value === '*') {
-                                const value =  this._expression(precedence, terminal, tuple === true ? true : false);
+                                const value =  this._parseExpression(precedence, terminal, tuple === true);
                                 node = new ast.Starred(value);
                             } else if (token.value === '**') {
-                                const value =  this._expression(precedence, terminal, tuple === true ? true : false);
+                                const value =  this._parseExpression(precedence, terminal, tuple === true);
                                 node = new ast.keyword(null, value);
                             } else {
                                 let op = null;
@@ -1108,7 +1111,7 @@ python.Execution = class {
                                     case 'not': op = new ast.Not(); break;
                                     default: throw new python.Error(`Unsupported unary operator ${token.value} ${this._location()}`);
                                 }
-                                const operand =  this._expression(precedence, terminal, tuple === true ? true : false);
+                                const operand =  this._parseExpression(precedence, terminal, tuple === true);
                                 node = new ast.UnaryOp(op, operand);
                                 node = this._mark(node, position);
                             }
@@ -1118,7 +1121,7 @@ python.Execution = class {
                     }
                     if (this._tokenizer.eat(':=')) {
                         const target = stack.pop();
-                        const value = this._expression(-1, terminal, tuple === false ? false : true);
+                        const value = this._parseExpression(-1, terminal, tuple !== false);
                         const node = new ast.NamedExpr(target, value);
                         this._mark(node, position);
                         stack.push(node);
@@ -1127,7 +1130,7 @@ python.Execution = class {
                     if (this._tokenizer.eat('=')) {
                         const position = this._position();
                         const targets = stack.pop();
-                        const value = this._expression(-1, terminal, tuple === false ? false : true);
+                        const value = this._parseExpression(-1, terminal, tuple !== false);
                         const node = new ast.Assign([targets], value);
                         this._mark(node, position);
                         stack.push(node);
@@ -1153,7 +1156,7 @@ python.Execution = class {
                     if (op) {
                         this._tokenizer.expect(token.type);
                         const target = stack.pop();
-                        const value = this._expression(-1, terminal, true);
+                        const value = this._parseExpression(-1, terminal, true);
                         const node = new ast.AugAssign(target, op, value);
                         stack.push(node);
                         continue;
@@ -1161,20 +1164,39 @@ python.Execution = class {
                     position = this._position();
                     if (this._eat('id', 'if')) {
                         const body = stack.pop();
-                        const test = this._expression();
+                        const test = this._parseExpression();
                         this._tokenizer.expect('id', 'else');
-                        const orelse = this._expression();
+                        const orelse = this._parseExpression();
                         const node = new ast.IfExp(test, body, orelse);
                         this._mark(node, position);
                         stack.push(node);
                         continue;
                     }
                     if (this._tokenizer.match('id', 'for') || this._tokenizer.match('id', 'async')) {
-                        throw new python.Error('Not implemented.');
+                        const position = this._position();
+                        const elt = stack.pop();
+                        const generators = this._parseGenerators();
+                        let node = null;
+                        if (elt instanceof ast.Dict) {
+                            if (elt.keys.length !== 1 || elt.values.length !== 1) {
+                                throw new python.Error(`Invalid dict comprehension ${this._location()}`);
+                            }
+                            node = new ast.DictComp(elt.keys[0], elt.values[0], generators);
+                        } else if (elt instanceof ast.Set) {
+                            if (elt.elts.length !== 1) {
+                                throw new python.Error(`Invalid set comprehension ${this._location()}`);
+                            }
+                            node = new ast.SetComp(elt.elts[0], generators);
+                        } else {
+                            node = new ast.GeneratorExp(elt, generators);
+                        }
+                        this._mark(node, position);
+                        stack.push(node);
+                        continue;
                     }
                     if (this._eat('id', 'lambda')) {
-                        const args = this._arguments(':');
-                        const body = this._expression(-1, terminal, false);
+                        const args = this._parseArguments(':');
+                        const body = this._parseExpression(-1, terminal, false);
                         const node = new ast.Lambda(args, body);
                         this._mark(node, position);
                         stack.push(node);
@@ -1182,13 +1204,13 @@ python.Execution = class {
                     }
                     if (this._eat('id', 'yield')) {
                         if (this._tokenizer.eat('id', 'from')) {
-                            const value = this._expression(-1, [], true);
+                            const value = this._parseExpression(-1, [], true);
                             node = new ast.YieldFrom(value);
                             stack.push(node);
                         } else {
                             const value = [];
                             do {
-                                value.push(this._expression(-1, [], false));
+                                value.push(this._parseExpression(-1, [], false));
                             }
                             while (this._tokenizer.eat(','));
                             node = new ast.Yield(value);
@@ -1197,7 +1219,7 @@ python.Execution = class {
                         continue;
                     }
                     if (this._eat('id', 'await')) {
-                        const value = this._expression(minPrecedence, terminal, tuple);
+                        const value = this._parseExpression(minPrecedence, terminal, tuple);
                         const node = new ast.Await(value);
                         this._mark(node, position);
                         stack.push(node);
@@ -1205,7 +1227,7 @@ python.Execution = class {
                     }
                     if (this._eat('.')) {
                         const value = stack.pop();
-                        const attr = this._name().id;
+                        const attr = this._parseName().id;
                         const node = new ast.Attribute(value, attr);
                         this._mark(node, position);
                         stack.push(node);
@@ -1222,7 +1244,7 @@ python.Execution = class {
                                 continue;
                             }
                             const position = this._position();
-                            const expr = this._expression(-1, [], false);
+                            const expr = this._parseExpression(-1, [], false);
                             if (expr === null) {
                                 throw new python.Error(`Expected expression ${this._location()}`);
                             }
@@ -1264,11 +1286,11 @@ python.Execution = class {
                     }
                     if (this._tokenizer.peek().type === '[') {
                         if (stack.length === 0) {
-                            stack.push(this._expressions());
+                            stack.push(this._parseList());
                         } else {
                             const value = stack.pop();
                             const position = this._position();
-                            const slice = this._slice();
+                            const slice = this._parseSlice();
                             node = new ast.Subscript(value, slice);
                             this._mark(node, position);
                             stack.push(node);
@@ -1282,7 +1304,7 @@ python.Execution = class {
                         this._tokenizer.expect('{');
                         let dict = true;
                         while (!this._tokenizer.eat('}')) {
-                            const item = this._expression(-1, [], false);
+                            const item = this._parseExpression(-1, [], false);
                             if (item === null) {
                                 throw new python.Error(`Expected expression ${this._location()}`);
                             }
@@ -1290,7 +1312,7 @@ python.Execution = class {
                                 dict = false;
                             }
                             if (dict) {
-                                const value = this._expression(-1, ['for'], false);
+                                const value = this._parseExpression(-1, ['for'], false);
                                 if (value === null) {
                                     throw new python.Error(`Expected expression ${this._location()}`);
                                 }
@@ -1298,12 +1320,12 @@ python.Execution = class {
                                     if (keys.length > 0 || values.length > 0 || elts.length > 0) {
                                         throw new python.Error(`Invalid list expression ${this._location()}`);
                                     }
-                                    const target = this._expression(-1, ['in'], true);
+                                    const target = this._parseExpression(-1, ['in'], true);
                                     this._tokenizer.expect('id', 'in');
-                                    const iter = this._expression(-1, ['for', 'if'], true);
+                                    const iter = this._parseExpression(-1, ['for', 'if'], true);
                                     const ifs = [];
                                     while (this._tokenizer.eat('id', 'if')) {
-                                        ifs.push(this._expression(-1, ['for', 'if']));
+                                        ifs.push(this._parseExpression(-1, ['for', 'if']));
                                     }
                                     const comprehension = new ast.comprehension(target, iter, ifs /*, async */);
                                     const generators = [comprehension];
@@ -1328,7 +1350,7 @@ python.Execution = class {
                         stack.push(node);
                         continue;
                     }
-                    const literal = this._literal();
+                    const literal = this._parseLiteral();
                     if (literal) {
                         if (stack.length > 0 &&
                             (literal.type === 'int' || literal.type === 'float' || literal.type === 'complex') &&
@@ -1386,7 +1408,7 @@ python.Execution = class {
                         stack.push(node);
                         continue;
                     }
-                    const name = this._name();
+                    const name = this._parseName();
                     if (name) {
                         stack.push(name);
                         continue;
@@ -1407,7 +1429,7 @@ python.Execution = class {
                         }
                         if (!this._tokenizer.match('=') && !terminalSet.has(this._tokenizer.peek().value)) {
                             const nextTerminal = terminal.slice(0).concat([',', '=']);
-                            const expression = this._expression(minPrecedence, nextTerminal, tuple);
+                            const expression = this._parseExpression(minPrecedence, nextTerminal, tuple);
                             if (expression) {
                                 node.elts.push(expression);
                                 continue;
@@ -1428,7 +1450,7 @@ python.Execution = class {
             _decorator() {
                 const list = [];
                 while (this._tokenizer.eat('@')) {
-                    const value = this._expression();
+                    const value = this._parseExpression();
                     if (!value || (value instanceof ast.Call === false && value instanceof ast.Name === false && value instanceof ast.Attribute === false)) {
                         throw new python.Error(`Invalid decorator ${this._location()}`);
                     }
@@ -1437,42 +1459,55 @@ python.Execution = class {
                 }
                 return list;
             }
-            _expressions() {
+            _parseGenerators() {
+                const generators = [];
+                while (this._tokenizer.match('id', 'for') || this._tokenizer.match('id', 'async')) {
+                    const is_async = this._eat('id', 'async') ? 1 : 0;
+                    this._tokenizer.expect('id', 'for');
+                    const target = this._parseExpression(-1, ['in'], true);
+                    this._tokenizer.expect('id', 'in');
+                    const iter = this._parseExpression(-1, ['for', 'if'], true);
+                    const ifs = [];
+                    while (this._tokenizer.eat('id', 'if')) {
+                        ifs.push(this._parseExpression(-1, ['for', 'if']));
+                    }
+                    const comprehension = new ast.comprehension(target, iter, ifs, is_async);
+                    generators.push(comprehension);
+                }
+                return generators;
+            }
+            _parseList() {
                 const elts = [];
                 this._tokenizer.expect('[');
-                while (!this._tokenizer.eat(']')) {
-                    const expression = this._expression(-1, ['for']);
-                    if (this._eat('id', 'for')) {
-                        if (elts.length > 0) {
-                            throw new python.Error(`Invalid list expression ${this._location()}`);
-                        }
-                        const target = this._expression(-1, ['in'], true);
-                        this._tokenizer.expect('id', 'in');
-                        const iter = this._expression(-1, ['for', 'if'], true);
-                        const ifs = [];
-                        while (this._tokenizer.eat('id', 'if')) {
-                            ifs.push(this._expression(-1, ['for', 'if']));
-                        }
-                        const comprehension = new ast.comprehension(target, iter, ifs /*, async */);
-                        const generators = [comprehension];
+                if (!this._tokenizer.match(']')) {
+                    const position = this._position();
+                    const expr = this._parseExpression(-1, ['for']);
+                    if (this._tokenizer.match('id', 'for')) {
+                        const generators = this._parseGenerators();
                         this._tokenizer.expect(']');
-                        return new ast.ListComp(expression, generators);
+                        const node = new ast.ListComp(expr, generators);
+                        this._mark(node, position);
+                        return node;
                     }
-                    if (expression === null) {
+                    if (expr === null) {
                         throw new python.Error(`Expected expression ${this._location()}`);
                     }
-                    elts.push(expression);
-                    this._tokenizer.eat(',');
-                    while (this._tokenizer.eat('\n')) {
-                        // continue
-                    }
-                    if (this._tokenizer.eat(']')) {
-                        break;
+                    elts.push(expr);
+                    while (this._tokenizer.eat(',')) {
+                        if (this._tokenizer.match(']')) {
+                            break;
+                        }
+                        const expr = this._parseExpression(-1, ['for']);
+                        if (!expr) {
+                            throw new python.Error(`Expected expression ${this._location()}`);
+                        }
+                        elts.push(expr);
                     }
                 }
+                this._tokenizer.expect(']');
                 return new ast.List(elts);
             }
-            _slice() {
+            _parseSlice() {
                 const elts = [];
                 let slice = [null, null, null];
                 let index = 0;
@@ -1494,7 +1529,7 @@ python.Execution = class {
                         }
                         this._tokenizer.expect(',');
                     } else {
-                        const expression = this._expression();
+                        const expression = this._parseExpression();
                         if (expression === null) {
                             throw new python.Error(`Expected expression ${this._location()}`);
                         }
@@ -1507,7 +1542,7 @@ python.Execution = class {
                 }
                 return elts[0];
             }
-            _name(required) {
+            _parseName(required) {
                 const token = this._tokenizer.peek();
                 if (token.type === 'id' && !token.keyword) {
                     const position = this._position();
@@ -1520,16 +1555,16 @@ python.Execution = class {
                 }
                 return null;
             }
-            _dottedName() {
+            _parseDottedName() {
                 const list = [];
                 do {
-                    const name = this._name(true);
+                    const name = this._parseName(true);
                     list.push(name.id);
                 }
                 while (this._tokenizer.eat('.'));
                 return list.join('.');
             }
-            _literal() {
+            _parseLiteral() {
                 const token = this._tokenizer.peek();
                 if (token.type === 'str' || token.type === 'bool' || token.type === 'int' || token.type === 'float' || token.type === 'complex') {
                     this._tokenizer.read();
@@ -1537,11 +1572,11 @@ python.Execution = class {
                 }
                 return null;
             }
-            _typeArguments() {
+            _parseTypeArguments() {
                 const list = [];
                 this._tokenizer.expect('[');
                 while (!this._tokenizer.eat(']')) {
-                    const type = this._type();
+                    const type = this._parseType();
                     if (type === null) {
                         throw new python.Error(`Expected type ${this._location()}`);
                     }
@@ -1553,11 +1588,11 @@ python.Execution = class {
                 }
                 return list;
             }
-            _type() {
-                const target = this._expression(-1, ['[', '=']);
+            _parseType() {
+                const target = this._parseExpression(-1, ['[', '=']);
                 if (target) {
                     if (this._tokenizer.peek().value === '[') {
-                        const list = this._expressions();
+                        const list = this._parseList();
                         const slice = list.elts.length === 1 ? list.elts[0] : new ast.Tuple(list.elts);
                         return new ast.Subscript(target, slice);
                     }
@@ -1565,7 +1600,7 @@ python.Execution = class {
                 }
                 return null;
             }
-            _arguments(terminal) {
+            _parseArguments(terminal) {
                 let posonlyargs = [];
                 let args = [];
                 let vararg = null;
@@ -1577,9 +1612,9 @@ python.Execution = class {
                 let is_vararg = false; // '*'
                 let is_kwarg = false; // '**'
                 const read = (required) => {
-                    const name = this._name(required);
+                    const name = this._parseName(required);
                     if (name) {
-                        const annotation = terminal !== ':' && this._tokenizer.eat(':') ? this._type() : null;
+                        const annotation = terminal !== ':' && this._tokenizer.eat(':') ? this._parseType() : null;
                         return new ast.arg(name.id, annotation, null);
                     }
                     return null;
@@ -1610,7 +1645,7 @@ python.Execution = class {
                             this._tokenizer.expect(terminal);
                             break;
                         }
-                        const default_value = this._tokenizer.eat('=') ? this._expression() : null;
+                        const default_value = this._tokenizer.eat('=') ? this._parseExpression() : null;
                         if (!is_vararg && !is_kwarg) {
                             if (is_slash) {
                                 args.push(arg);
@@ -2200,7 +2235,7 @@ python.Execution = class {
                         prefix = c;
                     }
                 } else if (this._get(i + 2) === "'" || this._get(i + 2) === '"') {
-                    const c = this._text.substr(this._position, 2);
+                    const c = this._text.substring(this._position, this._position + 2);
                     const cc = c.toLowerCase();
                     if (cc === 'br' || cc === 'fr' || cc === 'rb' || cc === 'rf' || cc === 'ur') {
                         prefix = c;
@@ -2335,6 +2370,9 @@ python.Execution = class {
             static __new__(cls, ...args) {
                 return execution.invoke(cls, args);
             }
+            static __setattr__(obj, name, value) {
+                builtins.setattr(obj, name, value);
+            }
         });
         this.registerType('builtins.tuple', class extends Array {
             constructor(items) {
@@ -2373,7 +2411,11 @@ python.Execution = class {
         typing.Sequence = Reflect.construct(typing._SpecialGenericAlias, []);
         typing.Tuple = Reflect.construct(typing._TupleType, []);
         typing.Union = Reflect.construct(typing._SpecialForm, []);
-        this.registerType('enum.Enum', class {});
+        this.registerType('enum.Enum', class {
+            // __reduce_ex__(proto) {
+            //    return self.__class__, (self._value_, )
+            // }
+        });
         this.registerFunction('operator.add');
         this.registerFunction('operator.eq');
         this.registerFunction('operator.ge');
@@ -3029,6 +3071,9 @@ python.Execution = class {
                 value.flags = this.flags;
                 return value;
             }
+            reshape(shape, order) {
+                return new numpy.ndarray(shape, this.dtype, this.data, this.offset, this.strides, order);
+            }
             tobytes() {
                 return this.data;
             }
@@ -3223,7 +3268,53 @@ python.Execution = class {
         this.registerType('pandas.core.arrays.categorical.Categorical', class {});
         this.registerType('pandas.core.arrays.datetimes.DatetimeArray', class {});
         this.registerType('pandas.core.arrays.integer.IntegerArray', class {});
-        this.registerType('pandas.core.frame.DataFrame', class {});
+        this.registerType('pandas.core.generic.Flags', class {});
+        this.registerType('pandas.core.generic.NDFrame', class {
+            constructor(data) {
+                this._internal_names = ["_mgr", "_item_cache", "_cache", "_name", "_metadata", "_flags"];
+                this._metadata = [];
+                builtins.object.__setattr__(self, "_mgr", data);
+                builtins.object.__setattr__(self, "_attrs", {});
+                builtins.object.__setattr__(self, "_flags", new pandas.core.generic.Flags(this, true));
+            }
+            __setstate__(state) {
+                if (state instanceof pandas.core.internals.managers.BlockManager) {
+                    this._mgr = state;
+                } else if (state instanceof builtins.dict) {
+                    if (state.__contains__('_data') && !state.__contains__('_mgr')) {
+                        state.__setitem__('_mgr', state.pop('_data'));
+                    }
+                    const typ = state.get('_typ');
+                    if (typ) {
+                        let attrs = state.get('_attrs', new builtins.dict());
+                        if (!attrs) {
+                            attrs = new builtins.dict();
+                        }
+                        builtins.object.__setattr__(this, '_attrs', attrs);
+                        const flags = state.get('_flags', new builtins.dict({ 'allows_duplicate_labels': true }));
+                        builtins.object.__setattr__(this, '_flags', new pandas.core.generic.Flags(this, flags));
+                        const meta = new builtins.set(this._internal_names.concat(this._metadata));
+                        for (const k of meta) {
+                            if (state.__contains__(k) && k !== '_flags') {
+                                const v = state.__getitem__(k);
+                                builtins.object.__setattr__(this, k, v);
+                            }
+                        }
+                        for (const [k, v] of state) {
+                            if (!meta.has(k)) {
+                                builtins.object.__setattr__(this, k, v);
+                            }
+                        }
+                    } else {
+                        throw new python.Error('Pre-0.12 pickles are no longer supported.');
+                    }
+                } else if (state.size === 2) {
+                    throw new python.Error('Pre-0.12 pickles are no longer supported.');
+                }
+            }
+        });
+        this.registerType('pandas.core.frame.DataFrame', class extends pandas.core.generic.NDFrame {
+        });
         this.registerFunction('pandas.core.indexes.base._new_Index', (cls, d) => {
             return new cls(d);
         });
@@ -3275,8 +3366,11 @@ python.Execution = class {
         pandas.core.internals.BlockManager = pandas.core.internals.managers.BlockManager;
         pandas._libs.tslib.Timestamp = pandas._libs.tslibs.timestamps.Timestamp;
         this.registerType('pathlib.Path', class {});
-        this.registerType('pathlib.PosixPath', class {});
-        this.registerType('pathlib.WindowsPath', class {});
+        this.registerType('pathlib._local.PosixPath', class {});
+        this.registerType('pathlib._local.WindowsPath', class {});
+        const pathlib = this.register('pathlib');
+        pathlib.PosixPath = pathlib._local.PosixPath;
+        pathlib.WindowsPath = pathlib._local.WindowsPath;
         this.registerType('shap._serializable.Serializable', class {});
         this.registerType('shap.explainers._explainer.Explainer', class extends shap._serializable.Serializable {});
         this.registerType('shap.explainers._linear.LinearExplainer', class extends shap.explainers._explainer.Explainer {});
@@ -3314,6 +3408,7 @@ python.Execution = class {
         this.registerType('sklearn.compose._target.TransformedTargetRegressor', class {});
         this.registerType('sklearn.cross_decomposition._pls.PLSRegression', class {});
         this.registerType('sklearn.decomposition._fastica.FastICA', class {});
+        this.registerType('sklearn.decomposition._incremental_pca.IncrementalPCA', class {});
         this.registerType('sklearn.decomposition._pca.PCA', class {});
         this.registerType('sklearn.decomposition._truncated_svd.TruncatedSVD', class {});
         this.registerType('sklearn.decomposition.pca.PCA', class {});
@@ -3342,6 +3437,7 @@ python.Execution = class {
         this.registerType('sklearn.ensemble._hist_gradient_boosting.predictor.TreePredictor', class {});
         this.registerType('sklearn.ensemble._iforest.IsolationForest', class {});
         this.registerType('sklearn.ensemble._stacking.StackingClassifier', class {});
+        this.registerType('sklearn.ensemble._stacking.StackingRegressor', class {});
         this.registerType('sklearn.ensemble._voting.VotingClassifier', class {});
         this.registerType('sklearn.ensemble._voting.VotingRegressor', class {});
         this.registerType('sklearn.ensemble._weight_boosting.AdaBoostClassifier', class {});
@@ -3407,6 +3503,7 @@ python.Execution = class {
         this.registerType('sklearn.linear_model._sgd_fast.ModifiedHuber', class {});
         this.registerType('sklearn.linear_model._sgd_fast.SquaredHinge', class {});
         this.registerType('sklearn.linear_model._stochastic_gradient.SGDClassifier', class {});
+        this.registerType('sklearn.linear_model._stochastic_gradient.SGDRegressor', class {});
         this.registerType('sklearn.linear_model.base.LinearRegression', class {});
         this.registerType('sklearn.linear_model.sgd_fast.Hinge', class {});
         this.registerType('sklearn.linear_model.LogisticRegression', class {});
@@ -3437,6 +3534,7 @@ python.Execution = class {
         this.registerType('sklearn.model_selection._split.RepeatedKFold', class {});
         this.registerType('sklearn.model_selection._split.StratifiedKFold', class {});
         this.registerType('sklearn.model_selection._split.StratifiedShuffleSplit', class {});
+        this.registerType('sklearn.model_selection._split.TimeSeriesSplit', class {});
         this.registerType('sklearn.multiclass.OneVsRestClassifier', class {});
         this.registerType('sklearn.multioutput.ClassifierChain', class {});
         this.registerType('sklearn.multioutput.MultiOutputClassifier', class {});
@@ -3595,6 +3693,9 @@ python.Execution = class {
                         }
                         case 112 : { // PUT 'p'
                             const index = parseInt(reader.line(), 10);
+                            if (stack.length === 0) {
+                                throw new python.Error(`Empty stack during 'PUT' operation.`);
+                            }
                             memo[index] = stack[stack.length - 1];
                             size++;
                             break;
@@ -3611,6 +3712,9 @@ python.Execution = class {
                             stack = marker.pop();
                             break;
                         case 50: // DUP '2'
+                            if (stack.length === 0) {
+                                throw new python.Error(`Empty stack during 'DUP' operation.`);
+                            }
                             stack.push(stack[stack.length - 1]);
                             break;
                         case 80: // PERSID 'P'
@@ -3661,10 +3765,16 @@ python.Execution = class {
                             stack.push(memo[reader.uint32()]);
                             break;
                         case 113: // BINPUT 'q'
+                            if (stack.length === 0) {
+                                throw new python.Error(`Empty stack during 'BINPUT' operation.`);
+                            }
                             memo[reader.byte()] = stack[stack.length - 1];
                             size++;
                             break;
                         case 114: // LONG_BINPUT 'r'
+                            if (stack.length === 0) {
+                                throw new python.Error(`Empty stack during 'LONG_BINPUT' operation.`);
+                            }
                             memo[reader.uint32()] = stack[stack.length - 1];
                             size++;
                             break;
@@ -3812,7 +3922,7 @@ python.Execution = class {
                         }
                         case 83: { // STRING 'S'
                             const str = reader.line();
-                            stack.push(str.substr(1, str.length - 2));
+                            stack.push(str.substring(1, str.length - 1));
                             break;
                         }
                         case 84: // BINSTRING 'T'
@@ -3846,9 +3956,11 @@ python.Execution = class {
                                     obj.set(key, value);
                                 }
                             } else if (obj instanceof Map) {
+                                /* eslint-disable guard-for-in */
                                 for (const key in state) {
                                     obj.set(key, state[key]);
                                 }
+                                /* eslint-enable guard-for-in */
                             } else if (state instanceof Map) {
                                 for (const [key, value] of state) {
                                     obj[key] = value;
@@ -3877,9 +3989,7 @@ python.Execution = class {
                             let number = 0;
                             switch (data.length) {
                                 case 0: number = 0; break;
-                                /* eslint-disable prefer-destructuring */
-                                case 1: number = data[0]; break;
-                                /* eslint-enable prefer-destructuring */
+                                case 1: [number] = data; break;
                                 case 2: number = data[1] << 8 | data[0]; break;
                                 case 3: number = data[2] << 16 | data[1] << 8 | data[0]; break;
                                 case 4: number = data[3] << 24 | data[2] << 16 | data[1] << 8 | data[0]; break;
@@ -4155,9 +4265,25 @@ python.Execution = class {
         types.TypeType = builtins.type;
         types.CodeType = builtins.code;
         this.registerType('xgboost.compat.XGBoostLabelEncoder', class {});
-        this.registerType('xgboost.core.Booster', class {});
+        this.registerType('xgboost.core.Booster', class {
+            load_model(fname) {
+                if (fname instanceof Uint8Array) {
+                    // XGBoosterLoadModel()
+                } else {
+                    // XGBoosterUnserializeFromBuffer(handle) {
+                }
+            }
+            __setstate__(state) {
+                const handle = state.get('handle');
+                if (handle) {
+                    this.handle = handle;
+                    // XGBoosterLoadModelFromBuffer()
+                }
+            }
+        });
         this.registerType('xgboost.sklearn.XGBClassifier', class {});
         this.registerType('xgboost.sklearn.XGBRegressor', class {});
+        this.registerType('xgboost.sklearn.XGBRFClassifier', class {});
         this.registerFunction('_codecs.encode', (obj, encoding) => {
             return execution.invoke('builtins.bytearray', [obj, encoding]);
         });
@@ -4303,7 +4429,16 @@ python.Execution = class {
         this.registerFunction('builtins.setattr', (obj, name, value) => {
             obj[name] = value;
         });
-        this.registerType('builtins.set', class extends Set {});
+        this.registerType('builtins.set', class extends Set {
+            __contains__(item) {
+                return this.has(item);
+            }
+            update(iterable) {
+                for (const item of iterable) {
+                    this.add(item);
+                }
+            }
+        });
         this.registerType('builtins.slice', class {
             constructor(start, stop, step) {
                 this.start = start;
@@ -4660,13 +4795,16 @@ python.Execution = class {
         this.registerFunction('nolearn.lasagne.base.objective');
         this.registerFunction('numpy.core._DType_reconstruct');
         this.registerFunction('numpy.core._ufunc_reconstruct');
-        this.registerFunction('numpy.core.numeric._frombuffer', (/* buf, dtype, shape, order */) => {
-            return {};
-        });
         this.registerFunction('numpy.core.multiarray._reconstruct', (subtype, shape, dtype) => {
             return numpy.ndarray.__new__(subtype, shape, dtype);
         });
-        this.registerFunction('numpy._core.numeric._frombuffer');
+        this.registerFunction('numpy.core.multiarray.frombuffer', (buf, dtype) => {
+            const shape = [buf.length / dtype.itemsize];
+            return new numpy.ndarray(shape, dtype, buf);
+        });
+        this.registerFunction('numpy._core.numeric._frombuffer', (buf, dtype, shape, order) => {
+            return numpy._core.multiarray.frombuffer(buf, dtype).reshape(shape, order);
+        });
         this.registerFunction('numpy._core._internal._convert_to_stringdtype_kwargs', () => {
             return new numpy.dtypes.StringDType();
         });
@@ -4762,10 +4900,12 @@ python.Execution = class {
                     throw new python.Error(`Unsupported scalar type '${dtype.__name__}'.`);
             }
         });
+        this.registerFunction('numpy.core._multiarray_umath.sin');
         this.registerFunction('numpy.core._multiarray_umath.sqrt');
         this.register('numpy._core.multiarray', numpy.core.multiarray);
         this.register('numpy._core._multiarray_umath', numpy.core._multiarray_umath);
         this.register('numpy._core._multiarray_umath', numpy.core._multiarray_umath);
+        this.register('numpy.core.numeric', numpy._core.numeric);
         numpy._core._multiarray_umath._reconstruct = numpy.core.multiarray._reconstruct;
         this.registerFunction('numpy.load', (file) => {
             // https://github.com/numpy/numpy/blob/main/numpy/lib/format.py
@@ -6745,6 +6885,8 @@ python.Execution = class {
         this.registerType('torch.distributions.beta.Beta', class {});
         this.registerType('torch.distributions.binomial.Binomial', class {});
         this.registerType('torch.distributions.categorical.Categorical', class {});
+        this.registerType('torch.distributions.constraints._GreaterThan', class {});
+        this.registerType('torch.distributions.constraints._Interval', class {});
         this.registerType('torch.distributions.constraints._LowerCholesky', class {});
         this.registerType('torch.distributions.constraints._Real', class {});
         this.registerType('torch.distributions.dirichlet.Dirichlet', class {});
@@ -6827,6 +6969,7 @@ python.Execution = class {
         this.registerType('torch.nn.modules.conv.LazyConv2d', class {});
         this.registerType('torch.nn.modules.conv.LazyConv3d', class {});
         this.registerType('torch.nn.modules.conv.LazyConvTranspose2d', class {});
+        this.registerType('torch.nn.modules.conv.LazyConvTranspose3d', class {});
         this.registerType('torch.nn.modules.distance.CosineSimilarity', class extends torch.nn.modules.module.Module {});
         this.registerType('torch.nn.modules.distance.PairwiseDistance', class extends torch.nn.modules.module.Module {});
         this.registerType('torch.nn.modules.dropout._DropoutNd', class extends torch.nn.modules.module.Module {});
@@ -6844,6 +6987,7 @@ python.Execution = class {
         this.registerType('torch.nn.modules.instancenorm.InstanceNorm2d', class {});
         this.registerType('torch.nn.modules.instancenorm.InstanceNorm3d', class {});
         this.registerType('torch.nn.modules.instancenorm.LazyInstanceNorm2d', class {});
+        this.registerType('torch.nn.modules.instancenorm.LazyInstanceNorm3d', class {});
         this.registerType('torch.nn.modules.linear._LinearWithBias', class {});
         this.registerType('torch.nn.modules.linear.Bilinear', class extends torch.nn.modules.module.Module {});
         this.registerType('torch.nn.modules.linear.Identity', class extends torch.nn.modules.module.Module {});
@@ -6892,9 +7036,11 @@ python.Execution = class {
         this.registerType('torch.nn.modules.padding.ReplicationPad3d', class extends torch.nn.modules.padding._ReplicationPadNd {});
         this.registerType('torch.nn.modules.padding.ZeroPad1d', class {});
         this.registerType('torch.nn.modules.padding.ZeroPad2d', class {});
+        this.registerType('torch.nn.modules.padding.ZeroPad3d', class {});
         this.registerType('torch.nn.modules.padding.ConstantPad1d', class {});
         this.registerType('torch.nn.modules.padding.ConstantPad2d', class {});
         this.registerType('torch.nn.modules.padding.ConstantPad3d', class {});
+        this.registerType('torch.nn.modules.padding.CircularPad3d', class {});
         this.registerType('torch.nn.modules.pixelshuffle.PixelShuffle', class {});
         this.registerType('torch.nn.modules.pixelshuffle.PixelUnshuffle', class {});
         this.registerType('torch.nn.modules.pooling._AdaptiveAvgPoolNd', class extends torch.nn.modules.module.Module {});
@@ -6908,8 +7054,10 @@ python.Execution = class {
         this.registerType('torch.nn.modules.pooling.AvgPool2d', class {});
         this.registerType('torch.nn.modules.pooling.AvgPool3d', class {});
         this.registerType('torch.nn.modules.pooling.FractionalMaxPool2d', class {});
+        this.registerType('torch.nn.modules.pooling.FractionalMaxPool3d', class {});
         this.registerType('torch.nn.modules.pooling.LPPool1d', class {});
         this.registerType('torch.nn.modules.pooling.LPPool2d', class {});
+        this.registerType('torch.nn.modules.pooling.LPPool3d', class {});
         this.registerType('torch.nn.modules.pooling._MaxPoolNd', class extends torch.nn.modules.module.Module {});
         this.registerType('torch.nn.modules.pooling.MaxPool1d', class extends torch.nn.modules.pooling._MaxPoolNd {});
         this.registerType('torch.nn.modules.pooling.MaxPool2d', class extends torch.nn.modules.pooling._MaxPoolNd {});
@@ -7011,8 +7159,10 @@ python.Execution = class {
         this.registerType('torch.ao.nn.quantized.reference.modules.linear.Linear', class {});
         this.registerType('torch.ao.nn.qat.modules.conv.Conv2d', class {});
         this.registerType('torch.ao.nn.qat.modules.linear.Linear', class {});
+        this.registerType('torch.ao.nn.intrinsic.quantized.modules.conv_relu.ConvReLU1d', class extends torch.ao.nn.quantized.modules.conv.Conv1d {});
         this.registerType('torch.ao.nn.intrinsic.quantized.modules.conv_relu.ConvReLU2d', class extends torch.ao.nn.quantized.modules.conv.Conv2d {});
         this.registerType('torch.ao.nn.intrinsic.quantized.modules.linear_relu.LinearReLU', class extends torch.ao.nn.quantized.modules.linear.Linear {});
+        this.registerType('torch.ao.nn.intrinsic.quantized.modules.bn_relu.BNReLU2d', class extends torch.ao.nn.quantized.modules.batchnorm.BatchNorm2d {});
         this.registerType('torch.ao.nn.intrinsic.modules.fused._FusedModule', class extends torch.nn.modules.container.Sequential {});
         this.registerType('torch.ao.nn.intrinsic.modules.fused.ConvBn2d', class extends torch.ao.nn.intrinsic.modules.fused._FusedModule {});
         this.registerType('torch.ao.nn.intrinsic.modules.fused.ConvReLU1d', class extends torch.ao.nn.intrinsic.modules.fused._FusedModule {});
@@ -7353,7 +7503,7 @@ python.Execution = class {
             }
             _target_to_str(target) {
                 if (typeof target === 'string') {
-                    if (target.startsWith('__') && target.endswith('__')) {
+                    if (target.startsWith('__') && target.endsWith('__')) {
                         target = target.substring(2, target.length - 2);
                     }
                 } else {
@@ -7397,6 +7547,7 @@ python.Execution = class {
         this.registerFunction('torch.fx._symbolic_trace.wrap', (fn_or_name) => {
             return fn_or_name;
         });
+        this.registerFunction('torch.fx._symbolic_trace._assert_is_none');
         this.registerFunction('torchvision.datasets.folder.default_loader');
         this.registerType('torchvision.datasets.folder.ImageFolder', class {});
         this.registerType('torchvision.datasets.mnist.FashionMNIST', class {});
@@ -7485,6 +7636,7 @@ python.Execution = class {
         this.registerType('torchvision.models.inception.InceptionC', class {});
         this.registerType('torchvision.models.inception.InceptionD', class {});
         this.registerType('torchvision.models.inception.InceptionE', class {});
+        this.registerFunction('torchvision.models.inception.inception_v3');
         this.registerType('torchvision.models.mnasnet._InvertedResidual', class {});
         this.registerType('torchvision.models.mnasnet.MNASNet', class {});
         this.registerType('torchvision.models.maxvit.MaxVit', class {});
@@ -7579,7 +7731,10 @@ python.Execution = class {
         this.registerType('torchvision.transforms.transforms.RandomAffine', class extends torch.nn.modules.module.Module {});
         this.registerType('torchvision.transforms.transforms.RandomApply', class extends torch.nn.modules.module.Module {});
         this.registerType('torchvision.transforms.transforms.RandomCrop', class extends torch.nn.modules.module.Module {});
+        this.registerType('torchvision.transforms.transforms.RandomChoice', class {});
         this.registerType('torchvision.transforms.transforms.RandomErasing', class {});
+        this.registerType('torchvision.transforms.transforms.RandomInvert', class {});
+        this.registerType('torchvision.transforms.transforms.RandomPerspective', class {});
         this.registerType('torchvision.transforms.transforms.RandomHorizontalFlip', class extends torch.nn.modules.module.Module {});
         this.registerType('torchvision.transforms.transforms.RandomVerticalFlip', class extends torch.nn.modules.module.Module {});
         this.registerType('torchvision.transforms.transforms.RandomResizedCrop', class extends torch.nn.modules.module.Module {});
@@ -7766,7 +7921,13 @@ python.Execution = class {
             }
             throw new python.Error(`Unsupported sparse tensor layout '${layout ? layout.__str__() : ''}'.`);
         });
-        this.registerFunction('torch._utils._rebuild_wrapper_subclass');
+        this.registerFunction('torch._utils._get_restore_location', (device) => {
+            return device;
+        });
+        this.registerFunction('torch._utils._rebuild_wrapper_subclass', (cls, dtype, size, stride, storage_offset, layout, device, requires_grad) => {
+            device = torch._utils._get_restore_location(device);
+            return torch.Tensor._make_wrapper_subclass(cls, size, stride, dtype, storage_offset, layout, device, requires_grad);
+        });
         this.registerFunction('torch.from_numpy', (obj) => {
             const dtypes = new Map([
                 ['<f2', torch.float16],
@@ -7801,6 +7962,12 @@ python.Execution = class {
             tensor._shape = size;
             return tensor;
         });
+        this.registerFunction('torch._utils.set_tensor_metadata', (tensor, metadata) => {
+            torch._C._set_tensor_metadata(tensor, metadata);
+        });
+        this.registerFunction('torch._utils._restore_device_fake_mode', (tensor) => {
+            return tensor;
+        });
         this.registerFunction('torch._utils._rebuild_meta_tensor_no_storage', (dtype, size, stride, requires_grad) => {
             return torch.empty_strided(size, stride, dtype, null, 'meta', false, requires_grad);
         });
@@ -7814,13 +7981,24 @@ python.Execution = class {
             tensor.__setstate__([storage, storage_offset, size, stride]);
             return tensor;
         });
-        this.registerFunction('torch._utils._rebuild_tensor_v2', (storage, storage_offset, size, stride, requires_grad, backward_hooks) => {
-            const tensor = execution.invoke('torch._utils._rebuild_tensor', [storage, storage_offset, size, stride]);
+        this.registerFunction('torch._utils._rebuild_tensor_v2', (storage, storage_offset, size, stride, requires_grad, backward_hooks, metadata) => {
+            const tensor = torch._utils._rebuild_tensor(storage, storage_offset, size, stride);
             tensor.requires_grad = requires_grad;
+            if (metadata) {
+                torch._utils.set_tensor_metadata(tensor, metadata);
+            }
             tensor.backward_hooks = backward_hooks;
             return tensor;
         });
-        this.registerFunction('torch._utils._rebuild_tensor_v3');
+        this.registerFunction('torch._utils._rebuild_tensor_v3', (storage, storage_offset, size, stride, requires_grad, backward_hooks, dtype, metadata) => {
+            const t = new torch.Tensor(null, null, dtype);
+            t.set_(storage, storage_offset, size, stride);
+            if (metadata) {
+                torch._utils.set_tensor_metadata(t, metadata);
+            }
+            t._backward_hooks = backward_hooks;
+            return torch._utils._restore_device_fake_mode(t);
+        });
         this.registerFunction('torch._utils._rebuild_parameter', (data, requires_grad, backward_hooks) => {
             const param = new torch.nn.parameter.Parameter(data, requires_grad);
             param.backward_hooks = backward_hooks;
@@ -8552,6 +8730,13 @@ python.Execution = class {
                 }
             }
             static get(kind, annotation_str) {
+                torch.Type.cache = torch.Type.cache || new Map();
+                if (!annotation_str) {
+                    if (!torch.Type.cache.has(kind)) {
+                        torch.Type.cache.set(kind, new torch.Type(kind));
+                    }
+                    return torch.Type.cache.get(kind);
+                }
                 return new torch.Type(kind, annotation_str);
             }
             kind() {
@@ -8788,6 +8973,49 @@ python.Execution = class {
                 return this.qualified_name();
             }
         });
+        this.registerType('torch.EnumType', class extends torch.Type {
+            constructor(qualified_class_name, value_type, enum_names_values, cu) {
+                super('EnumType', qualified_class_name);
+                this._name = qualified_class_name;
+                this._value_type = value_type;
+                this._enum_names_values = enum_names_values;
+                this._cu = cu;
+            }
+            static create(qualified_class_name, value, enum_names_values, cu) {
+                if (value instanceof torch.IntType || value instanceof torch.FloatType || value instanceof torch.StringType) {
+                    return new torch.EnumType(qualified_class_name, value, enum_names_values, cu);
+                }
+                torch._C.TORCH_CHECK(false);
+                return null;
+            }
+            name() {
+                return this._name;
+            }
+            get annotation_str() {
+                return this._name.qualifiedName();
+            }
+            enumNamesValues() {
+                return this._enum_names_values;
+            }
+            compilation_unit() {
+                return this._cu;
+            }
+            getValueType() {
+                return this._value_type;
+            }
+            equals(rhs) {
+                if (rhs instanceof torch.EnumType) {
+                    return this.name() && this.name() === rhs.name() && this.getValueType() === rhs.getValueType() && this.compilation_unit() === rhs.compilation_unit();
+                }
+                return false;
+            }
+            isSubtypeOf(rhs) {
+                if (rhs instanceof torch.AnyType || rhs.kind() === 'AnyEnumType' || this === rhs) {
+                    return true;
+                }
+                return super.isSubtypeOf(rhs);
+            }
+        });
         this.registerFunction('torch._C.standardizeVectorForUnion', (...args) => {
             if (args.length === 1) {
                 const [to_flatten] = args;
@@ -10402,7 +10630,7 @@ python.Execution = class {
                     }
                     return torch._C.collectQualname(expr);
                 }
-                throw new python.Error('Unsupported type.');
+                throw new python.Error(`Unsupported type '${expr.__class__.__name__}'.`);
             }
             parseBroadcastList(/* expr */) {
                 return null;
@@ -10659,6 +10887,12 @@ python.Execution = class {
                 n.output().setType(typ);
                 return n;
             }
+            createEnumValue(e) {
+                const enum_type = e.type().expect(torch.EnumType);
+                const n = this.create('prim::EnumValue', [e]);
+                n.output().setType(enum_type.getValueType());
+                return n;
+            }
             createList(contained_type, values) {
                 const n = this.create('prim::ListConstruct', values);
                 for (const v of values) {
@@ -11718,6 +11952,8 @@ python.Execution = class {
                     this.tag = 'Int';
                 } else if (typeof value === 'number') {
                     this.tag = 'Double';
+                } else if (value instanceof torch._C.EnumHolder) {
+                    this.tag = 'Enum';
                 } else {
                     throw new python.Error('Unsupported type.');
                 }
@@ -11787,9 +12023,15 @@ python.Execution = class {
             isStream() {
                 return this.tag === 'Stream';
             }
+            isGenericDict() {
+                return this.tag === 'GenericDict';
+            }
             isEnum() {
                 return this.tag === 'Enum';
             }
+            toEnumHolder() {
+                return this.value;
+            }
             isTuple() {
                 return this.tag === 'Tuple';
             }
@@ -11800,35 +12042,39 @@ python.Execution = class {
                 return torch._C.isCustomClass(this);
             }
             equals(rhs) {
-                const lhs = this;
-                switch (lhs.tag) {
+                switch (this.tag) {
                     case 'None': return rhs.isNone();
-                    case 'Bool': return rhs.isBool() && lhs.toBool() === rhs.toBool();
-                    case 'Int': return rhs.isInt() && lhs.toInt() === rhs.toInt();
-                    case 'Double': return rhs.isDouble() && lhs.toDouble() === rhs.toDouble();
-                    case 'String': return rhs.isString() && lhs.toString() === rhs.toString();
-                    case 'Tensor': return rhs.isTensor() && lhs.toTensor() === rhs.toTensor();
-                    case 'Object': return rhs.isObject() && lhs.toObject() === rhs.toObject();
-                    case 'Device': return rhs.isObject() && lhs.toDevice() === rhs.toDevice();
+                    case 'Bool': return rhs.isBool() && this.toBool() === rhs.toBool();
+                    case 'Int': return rhs.isInt() && this.toInt() === rhs.toInt();
+                    case 'Double': return rhs.isDouble() && this.toDouble() === rhs.toDouble();
+                    case 'String': return rhs.isString() && this.toString() === rhs.toString();
+                    case 'Tensor': return rhs.isTensor() && this.toTensor() === rhs.toTensor();
+                    case 'Object': return rhs.isObject() && this.toObject() === rhs.toObject();
+                    case 'Device': return rhs.isObject() && this.toDevice() === rhs.toDevice();
                     case 'GenericList': {
                         if (rhs.isList()) {
-                            const a = lhs.toList();
+                            const a = this.toList();
                             const b = rhs.toList();
                             return (a.length === b.length) && a.every((v, i) => v === b[i]);
                         }
                         return false;
                     }
-                    default: throw new python.Error(`IValue.equals() not implemented for '${lhs.tag}.`);
+                    default: throw new python.Error(`IValue.equals() not implemented for '${this.tag}.`);
                 }
             }
             is(rhs) {
-                const lhs = this;
-                return lhs.equals(rhs);
+                return this.equals(rhs);
             }
             type() {
                 switch (this.tag) {
+                    case 'None': return torch.NoneType.get();
+                    case 'Bool': return torch.BoolType.get();
                     case 'Int': return torch.IntType.get();
+                    case 'Double': return torch.FloatType.get();
+                    case 'String': return torch.StringType.get();
+                    case 'Device': return torch.DeviceObjType.get();
                     case 'Tuple': return torch.TupleType.create(this.value.elements().map((ivalue) => ivalue.type()));
+                    case 'Enum': return this.toEnumHolder().type();
                     default: throw new python.Error(`IValue.type('${this.tag}') not implemented.`);
                 }
             }
@@ -12064,8 +12310,8 @@ python.Execution = class {
                 }
                 const graph = m.graph();
                 switch (name) {
-                    case 'inf': return new torch._C.SimpleValue(graph.insertConstant('std::numeric_limits<double>::infinity()', loc));
-                    case 'nan': return new torch._C.SimpleValue(graph.insertConstant('std::numeric_limits<double>::quiet_NaN()', loc));
+                    case 'inf': return new torch._C.SimpleValue(graph.insertConstant(Infinity /* 'std::numeric_limits<double>::infinity()' */, loc));
+                    case 'nan': return new torch._C.SimpleValue(graph.insertConstant(NaN /* 'std::numeric_limits<double>::quiet_NaN()' */, loc));
                     case 'infj': return new torch._C.SimpleValue(graph.insertConstant('c10::complex<double>(0, std::numeric_limits<double>::infinity())', loc));
                     case 'nanj': return new torch._C.SimpleValue(graph.insertConstant('c10::complex<double>(0, std::numeric_limits<double>::quiet_NaN()', loc));
                     case '__torch__': return new torch._C.ClassNamespaceValue(new torch._C.QualifiedName(name), this);
@@ -12102,7 +12348,7 @@ python.Execution = class {
                 } else if (superclass_name === 'ModuleInterface') {
                     // this._cu.define_interface(qualified_name, class_def, shared_from_this(), is_module=true);
                 } else if (superclass_name === 'Enum') {
-                    // importEnum(qualified_name, class_def);
+                    this.importEnum(qualified_name, class_def);
                 } else {
                     throw new python.Error('TorchScript does not support class inheritance.');
                 }
@@ -12214,6 +12460,56 @@ python.Execution = class {
                 const self = new torch._C.SimpleSelf(class_type);
                 this._cu.define(qualified_classname, [], [], methods, method_resolvers, self, false, this._version);
             }
+            importEnum(qualified_name, enum_def) {
+                const names_values = [];
+                let value_type = null;
+                const set_or_check_type = (t) => {
+                    if (!value_type) {
+                        value_type = t;
+                    } else if (value_type !== t) {
+                        throw new python.Error('Enum class with varying value types are not supported.');
+                    }
+                };
+                for (const stmt of enum_def.body) {
+                    if (stmt instanceof ast.Assign === false) {
+                        throw new python.Error('Unexpected statement in Enum class body.');
+                    }
+                    const assign = stmt;
+                    const name = assign.targets[0].id;
+                    let ivalue = null;
+                    const rhs = assign.value;
+                    switch (rhs.type) {
+                        case 'str':
+                            ivalue = new torch._C.IValue(rhs.value);
+                            set_or_check_type(torch.StringType.get());
+                            break;
+                        default:
+                            throw new python.Error(`Unsupported enum value type '${rhs.type}'.`);
+                            /*
+                        case TK_CONST: {
+                            auto numeric_const = Const(rhs);
+                            if (numeric_const.isFloatingPoint()) {
+                            ivalue = IValue(numeric_const.asFloatingPoint());
+                            set_or_check_type(FloatType::get(), statement.range());
+                            } else if (numeric_const.isIntegral()) {
+                            ivalue = IValue(numeric_const.asIntegral());
+                            set_or_check_type(IntType::get(), statement.range());
+                            }
+                            break;
+                        }
+                        default:
+                            throw(ErrorReport(rhs.range()) << "Unsupported enum value type: " << rhs.kind() << ". Only Integers, Floats and Strings are supported.");
+                        }
+                        */
+                    }
+                    names_values.push([name, ivalue]);
+                }
+                if (!value_type) {
+                    throw new python.Error('No enum values defined.');
+                }
+                const enum_type = torch.EnumType.create(qualified_name, value_type, names_values, this._cu);
+                this._cu.register_type(enum_type);
+            }
             importNamedTuple(qualified_name, named_tuple_def) {
                 const type_parser = new torch._C.ScriptTypeParser(this);
                 const field_names = [];
@@ -12478,40 +12774,6 @@ python.Execution = class {
                 execution.builtins.inf = torch.inf;
                 execution.builtins.CONSTANTS = {};
                 execution._resolver = this._source_importer;
-                const known_types = [
-                    { name: '__torch__.torch.classes._nnapi.Compilation', methods: [
-                        '__init__(__torch__.torch.classes._nnapi.Compilation self) -> NoneType',
-                        'init(__torch__.torch.classes._nnapi.Compilation self, Tensor serialized_model_tensor, Tensor[] parameter_buffers) -> NoneType',
-                        'init2(__torch__.torch.classes._nnapi.Compilation self, Tensor serialized_model_tensor, Tensor[] parameter_buffers, int compilation_preference, bool relax_f32_to_f16) -> NoneType',
-                        'run(__torch__.torch.classes._nnapi.Compilation self, Tensor[] inputs, Tensor[] outputs) -> NoneType'
-                    ] },
-                    { name: '__torch__.torch.classes.quantized.Conv2dPackedParamsBase', attributes: 'Tensor weight, Tensor bias, int[] stride, int[] padding, int[] dilation, int groups', methods: ['unpack(__torch__.torch.classes.quantized.Conv2dPackedParamsBase self) -> ((Tensor, Tensor?))'] },
-                    { name: '__torch__.torch.classes.quantized.Conv3dPackedParamsBase', attributes: 'Tensor weight, Tensor bias, int[] stride, int[] padding, int[] dilation, int groups', methods: ['unpack(__torch__.torch.classes.quantized.Conv3dPackedParamsBase self) -> ((Tensor, Tensor?))'] },
-                    { name: '__torch__.torch.classes.quantized.LinearPackedParamsBase', attributes: 'Tensor weight, Tensor? bias' },
-                    { name: '__torch__.torch.classes.rnn.CellParamsBase', attributes: 'str type, Tensor[] tensors, float[] doubles, int[] longs, __torch__.torch.classes.quantized.LinearPackedParamsBase[] packed_params' },
-                    { name: '__torch__.torch.classes.xnnpack.Conv2dOpContext', attributes: 'Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] dilation, int groups, int[] output_min, int[] output_max' },
-                    { name: '__torch__.torch.classes.xnnpack.LinearOpContext', attributes: 'Tensor weight, Tensor bias, int[] output_min, int[] output_max' },
-                    { name: '__torch__.torch.classes.xnnpack.TransposeConv2dOpContext', attributes: 'Tensor weight, Tensor? bias, int[] stride, int[] padding, int[] output_padding, int[] dilation, int groups, int[] output_min, int[] output_max' },
-                    { name: '__torch__.torch.classes.tensorrt.Engine' }
-                ];
-                for (const known_type of known_types) {
-                    const prefix = new torch._C.QualifiedName(known_type.name);
-                    const type = torch.ClassType.create(known_type.name, this._compilation_unit, false);
-                    for (const known_method of known_type.methods || []) {
-                        const schema = new torch.FunctionSchema(known_method);
-                        const name = new torch._C.QualifiedName(prefix, schema.name);
-                        const fn = new torch._C.BuiltinOpFunction(name, schema);
-                        type.addMethod(fn);
-                    }
-                    if (known_type.attributes) {
-                        const schema = new torch.FunctionSchema(`(${known_type.attributes}) -> ()`);
-                        for (const arg of schema.arguments) {
-                            type.addAttribute(arg.name, arg.real_type);
-                        }
-                    }
-                    torch._C.registerCustomClass(type);
-                    // this._compilation_unit.register_type(type);
-                }
                 if (this._reader.has_record('model.json')) {
                     return this.LEGACY_deserialize();
                 }
@@ -12771,7 +13033,9 @@ python.Execution = class {
                 this.error_messages = new Map();
             }
             setVariableTypeError(name, msg) {
+                /* eslint-disable consistent-this */
                 let runner = this;
+                /* eslint-enable consistent-this */
                 while (runner.next) {
                     runner = runner.next;
                 }
@@ -12806,7 +13070,10 @@ python.Execution = class {
                 this.type_table.set(name, type);
             }
             findInAnyFrame(name) {
-                for (let runner = this; runner; runner = runner.next) {
+                /* eslint-disable consistent-this */
+                const self = this;
+                /* eslint-enable consistent-this */
+                for (let runner = self; runner; runner = runner.next) {
                     const r = runner.findInThisFrame(name);
                     if (r) {
                         return r;
@@ -12868,6 +13135,7 @@ python.Execution = class {
                         ['hasattr', torch._C.SpecialFormValue.create('prim::HasAttr')],
                         ['isinstance', torch._C.SpecialFormValue.create('prim::isinstance')],
                         ['range', torch._C.SpecialFormValue.create('prim::range')],
+                        ['sorted', new torch._C.BuiltinFunction('aten::sorted', null)],
                     ]);
                     if (torch._C.Environment.globals.has(ident)) {
                         retval = torch._C.Environment.globals.get(ident);
@@ -13117,7 +13385,7 @@ python.Execution = class {
             }
             for (const entry of torch._C.get_operator_version_map()) {
                 const old_symbol_name = entry.first;
-                const base_name = old_symbol_name.substr(0, old_symbol_name.find('.'));
+                const base_name = old_symbol_name.substring(0, old_symbol_name.find('.'));
                 if (base_name === name) {
                     const possibleUpgrader = torch._C.findUpgrader(entry.second, version.value());
                     if (possibleUpgrader.has_value()) {
@@ -14024,17 +14292,17 @@ python.Execution = class {
                     }
                 } else if (this._value.type() instanceof torch.InterfaceType) {
                     throw new python.Error('Not implemented.');
-                } /* else if (this._value.type() instanceof torch.EnumType) {
+                } else if (this._value.type() instanceof torch.EnumType) {
                     const g = m.graph();
-                    if (field == 'name') {
-                        const n = g.insertNode(g.createEnumName(value_));
-                        return std::make_shared<SimpleValue>(n->output());
+                    if (field === 'name') {
+                        const n = g.insertNode(g.createEnumName(this._value));
+                        return new torch._C.SimpleValue(n.output());
                     }
-                    if (field == 'value') {
-                        const n = g.insertNode(g.createEnumValue(value_));
-                        return std::make_shared<SimpleValue>(n->output());
+                    if (field === 'value') {
+                        const n = g.insertNode(g.createEnumValue(this._value));
+                        return new torch._C.SimpleValue(n.output());
                     }
-                } */
+                }
                 if (field === 'type') {
                     const builtin = torch._C.BuiltinFunction.tryCreate('aten::to', new torch._C.NamedValue(loc, 'self', this._value));
                     if (builtin) {
@@ -14181,6 +14449,31 @@ python.Execution = class {
                 return new torch._C.SimpleValue(self);
             }
         });
+        this.registerType('torch._C.SugaredEnumClass', class extends torch._C.SugaredValue {
+            constructor(enum_type) {
+                super();
+                this._enum_type = enum_type;
+            }
+            attr(loc, m, field) {
+                const names_values = this._enum_type.enumNamesValues();
+                const it = names_values.find((nv) => nv[0] === field);
+                if (it === null) {
+                    throw new python.Error(`Enum '${this._enum_type.name()}' has no attribute '${field}'.`);
+                }
+                const enum_holder = new torch._C.EnumHolder(this._enum_type, it[0], it[1]);
+                return new torch._C.SimpleValue(m.graph().insertConstant(new torch._C.IValue(enum_holder), loc));
+            }
+        });
+        this.registerType('torch._C.EnumHolder', class {
+            constructor(type, name, value) {
+                this._type = type;
+                this._name = name;
+                this._value = value;
+            }
+            type() {
+                return this._type;
+            }
+        });
         this.registerType('torch._C.FunctionValue', class extends torch._C.SugaredValue {
             constructor(...args) {
                 super();
@@ -14691,6 +14984,8 @@ python.Execution = class {
         this.registerFunction('torch._C._jit_pass_inline', (graph) => {
             torch._C.Inline(graph);
         });
+        this.registerFunction('torch._C._set_tensor_metadata', (/* tensor, metadata */) => {
+        });
         this.registerFunction('torch.jit._script.unpackage_script_module', (importer, script_module_id) => {
             const cu = new torch.jit.CompilationUnit();
             cu.execution = execution;
@@ -14767,6 +15062,17 @@ python.Execution = class {
             _type() {
                 return this._typ; // torch.ClassType
             }
+            __setstate__(state) {
+                const [attrs, qualname] = state;
+                this._typ = torch._C.getCustomClass(qualname);
+                if (!this._typ) {
+                    throw new python.Error(`Unsupported custom class '${qualname}'.`);
+                }
+                for (let i = 0; i < this._typ.numAttributes(); i++) {
+                    const name = this._typ.getAttributeName(i);
+                    this.__setattr__(name, attrs[i]);
+                }
+            }
             find_method(basename) {
                 for (const fn of this.type().methods()) {
                     if (fn.name() === basename) {
@@ -14786,6 +15092,9 @@ python.Execution = class {
             _has_method(name) {
                 return this.find_method(name) ? true : false;
             }
+            _method_names() {
+                return this.type().methods().map((fn) => fn.name());
+            }
             __setattr__(name, value) {
                 // if (this._type.hasContant(name))
                 this._ivalue[name] = value;
@@ -15374,7 +15683,7 @@ python.Execution = class {
                     if (save_false.findInAnyFrame(v) || false_exits) {
                         mutated_variables.add(v);
                     } else {
-                        this.environment_stack.setVariableTypeError(v, () => 'Value is is not defined in the false branch.');
+                        this.environment_stack.setVariableTypeError(v, () => 'Value is not defined in the false branch.');
                     }
                     insert.dispose();
                 }
@@ -15383,7 +15692,7 @@ python.Execution = class {
                     if (save_true.findInAnyFrame(v) || true_exits) {
                         mutated_variables.add(v);
                     } else {
-                        this.environment_stack.setVariableTypeError(v, () => 'Value is is not defined in the true branch.');
+                        this.environment_stack.setVariableTypeError(v, () => 'Value is not defined in the true branch.');
                     }
                     insert.dispose();
                 }
@@ -15448,18 +15757,25 @@ python.Execution = class {
             }
             refineAndSetUnionTypeHintOrPopulateCandidatesVector(type_hint, refined_type_hint_ptr, all_candidates, match_repr, src, type_match, do_if_match, do_if_anytype, is_dict_constructor) {
                 is_dict_constructor = is_dict_constructor || false;
-                if (refined_type_hint_ptr instanceof torch.UnionType) {
-                    throw new python.Error('Not implemented.');
-                } else if (refined_type_hint_ptr instanceof torch.OptionalType) {
-                    refined_type_hint_ptr = refined_type_hint_ptr.getElementType();
+                if (refined_type_hint_ptr._ instanceof torch.UnionType) {
+                    const candidate_types = refined_type_hint_ptr._.containedTypes().filter((type_ptr) => type_match(type_ptr));
+                    if (!is_dict_constructor && candidate_types.length === 0) {
+                        throw new python.Error("No matching types found in Union type annotation.");
+                    } else if (candidate_types.length === 1) {
+                        [refined_type_hint_ptr._] = candidate_types;
+                    } else {
+                        all_candidates._ = candidate_types;
+                    }
+                } else if (refined_type_hint_ptr._ instanceof torch.OptionalType) {
+                    refined_type_hint_ptr._ = refined_type_hint_ptr._.getElementType();
                 }
                 if (is_dict_constructor) {
                     return;
                 }
-                if (all_candidates.length === 0) {
-                    if (type_match(refined_type_hint_ptr)) {
+                if (all_candidates._.length === 0) {
+                    if (type_match(refined_type_hint_ptr._)) {
                         do_if_match();
-                    } else if (refined_type_hint_ptr.kind() === 'AnyType') {
+                    } else if (refined_type_hint_ptr._.kind() === 'AnyType') {
                         do_if_anytype();
                     } else {
                         throw new python.Error('Invalid annotation type.');
@@ -15870,14 +16186,14 @@ python.Execution = class {
                         rhs_value_type = torch._C.unifyTypes(rhs_value_type, values[i].type(), /*default_to_union=*/true);
                     }
                 }
-                let refined_type_hint = type_hint;
+                const refined_type_hint = { _: type_hint };
                 const annotated_union_type = type_hint && type_hint.isUnionType() ? type_hint : null;
-                const all_candidates = [];
+                const all_candidates = { _: [] };
                 const default_refined_type_hint_setter = () => {
                     if (keys.length === 0) {
-                        refined_type_hint = torch.DictType.create(torch.StringType.get(), torch.TensorType.get());
+                        refined_type_hint._ = torch.DictType.create(torch.StringType.get(), torch.TensorType.get());
                     } else {
-                        refined_type_hint = torch.DictType.create(keys[0].type(), rhs_value_type);
+                        refined_type_hint._ = torch.DictType.create(keys[0].type(), rhs_value_type);
                         if (rhs_value_type instanceof torch.UnionType) {
                             throw new python.Error('Dict values consist of heterogeneous types.');
                         }
@@ -15886,25 +16202,25 @@ python.Execution = class {
                 if (type_hint) {
                     const type_match = (t) => t instanceof torch.DictType;
                     this.refineAndSetUnionTypeHintOrPopulateCandidatesVector(type_hint, refined_type_hint, all_candidates, 'Dict', dl, type_match, () => [], default_refined_type_hint_setter);
-                    if (all_candidates.length > 0 && values.length === 0) {
+                    if (all_candidates._.length > 0 && values.length === 0) {
                         throw new python.Error('Cannot assign an empty dict.');
                     }
                 } else {
                     default_refined_type_hint_setter();
                 }
-                torch._C.TORCH_INTERNAL_ASSERT(all_candidates.length > 0 || refined_type_hint);
+                torch._C.TORCH_INTERNAL_ASSERT(all_candidates._.length > 0 || refined_type_hint._);
                 if (values.length > 0) {
-                    if (all_candidates.length > 0) {
+                    if (all_candidates._.length > 0) {
                         this.refineAndSetDictTypeHintFromCandidatesVector(all_candidates, type_hint, refined_type_hint, keys[0].type(), rhs_value_type, dl);
                     }
-                    if (refined_type_hint.getKeyType() !== keys[0].type()) {
+                    if (refined_type_hint._.getKeyType() !== keys[0].type()) {
                         throw new python.Error('Type annotation does not match key type.');
                     }
-                    if (!rhs_value_type.isSubtypeOf(refined_type_hint.getValueType())) {
+                    if (!rhs_value_type.isSubtypeOf(refined_type_hint._.getValueType())) {
                         throw new python.Error('Type annotation does not match value type.');
                     }
                 }
-                let result = this.graph.insertNode(this.graph.createDict(refined_type_hint.getKeyType(), refined_type_hint.getValueType(), keys, values));
+                let result = this.graph.insertNode(this.graph.createDict(refined_type_hint._.getKeyType(), refined_type_hint._.getValueType(), keys, values));
                 if (annotated_union_type) {
                     const n = this.graph.insertNode(this.graph.create('prim::unchecked_cast', [result.output()]));
                     n.output().setType(annotated_union_type);
@@ -15932,34 +16248,34 @@ python.Execution = class {
                     throw new python.Error('Not implemented.');
                 }
                 let inferred_elem_type = torch.TensorType.get();
-                const refined_type_hint = type_hint;
-                const annotated_union_type = refined_type_hint && refined_type_hint.isUnionType() ? refined_type_hint : null;
-                const all_candidates = [];
-                if (refined_type_hint) {
+                const refined_type_hint = { _: type_hint };
+                const annotated_union_type = refined_type_hint._ && refined_type_hint._.isUnionType() ? refined_type_hint._ : null;
+                const all_candidates = { _: [] };
+                if (refined_type_hint._) {
                     const do_if_type_match = () => {
-                        inferred_elem_type = refined_type_hint.expect(torch.ListType).getElementType();
+                        inferred_elem_type = refined_type_hint._.expect(torch.ListType).getElementType();
                     };
                     const type_match = (t) => t.isSubtypeOf(torch.Type.get('AnyListType'));
                     this.refineAndSetUnionTypeHintOrPopulateCandidatesVector(type_hint, refined_type_hint, all_candidates, 'List', ll, type_match, do_if_type_match, do_if_type_match);
-                    if (all_candidates.length > 0 && values.len === 0) {
+                    if (all_candidates._.length > 0 && values.len === 0) {
                         throw new python.Error('Cannot assign an empty list.');
                     }
                 }
                 if (values.length !== 0) {
                     const types = values.map((v) => v.type());
-                    const elem_type_hint = refined_type_hint && refined_type_hint.kind() === 'ListType' ? refined_type_hint.getElementType() : null;
+                    const elem_type_hint = refined_type_hint._ && refined_type_hint._.kind() === 'ListType' ? refined_type_hint._.getElementType() : null;
                     const unified_elem_type = torch._C.unifyTypeList(types, null /*nowhere*/, /*default_to_union=*/true, elem_type_hint);
-                    if (!refined_type_hint && unified_elem_type.kind() === 'UnionType') {
+                    if (!refined_type_hint._ && unified_elem_type.kind() === 'UnionType') {
                         throw new python.Error('Not implemented.');
                     }
-                    if (all_candidates.length === 0 && refined_type_hint && !unified_elem_type.isSubtypeOf(inferred_elem_type)) {
+                    if (all_candidates._.length === 0 && refined_type_hint._ && !unified_elem_type.isSubtypeOf(inferred_elem_type)) {
                         throw new python.Error('Not implemented.');
                     }
-                    if (all_candidates.length !== 0) {
-                        this.refineAndSetListTypeHintFromCandidatesVector(all_candidates, type_hint, refined_type_hint, unified_elem_type, ll);
-                        inferred_elem_type = refined_type_hint.expect(torch.ListType).getElementType();
+                    if (all_candidates._.length !== 0) {
+                        this.refineAndSetListTypeHintFromCandidatesVector(all_candidates, type_hint, refined_type_hint._, unified_elem_type, ll);
+                        inferred_elem_type = refined_type_hint._.expect(torch.ListType).getElementType();
                     }
-                    if (!refined_type_hint) {
+                    if (!refined_type_hint._) {
                         inferred_elem_type = unified_elem_type;
                     }
                 }
@@ -16368,7 +16684,10 @@ python.Execution = class {
                 return null;
             }
             findInAnyFrame(name) {
-                for (let runner = this; runner; runner = runner.next) {
+                /* eslint-disable consistent-this */
+                const self = this;
+                /* eslint-enable consistent-this */
+                for (let runner = self; runner; runner = runner.next) {
                     const r = runner.findInThisFrame(name);
                     if (r) {
                         return r;
@@ -17448,29 +17767,25 @@ python.Execution = class {
                     this.as_tensor = new torch._export.serde.schema.TensorArgument(this.as_tensor);
                 } else if (this.type === 'as_tensors') {
                     this.as_tensors = this.as_tensors.map((item) => new torch._export.serde.schema.TensorArgument(item));
+                } else if (this.type === 'as_graph') {
+                    this.as_graph = new torch._export.serde.schema.GraphArgument(this.as_graph);
                 } else if (this.type === 'as_sym_int') {
                     this.as_sym_int = new torch._export.serde.schema.SymIntArgument(this.as_sym_int);
                 } else if (this.type === 'as_sym_ints') {
                     this.as_sym_ints = this.as_sym_ints.map((item) => new torch._export.serde.schema.SymIntArgument(item));
+                } else if (this.type === 'as_sym_bool') {
+                    this.as_sym_bool = new torch._export.serde.schema.SymBoolArgument(this.as_sym_bool);
+                } else if (this.type === 'as_sym_bools') {
+                    this.as_sym_bools = this.as_sym_bools.map((item) => new torch._export.serde.schema.SymBoolArgument(item));
                 } else if (this.type === 'as_optional_tensors') {
                     this.as_optional_tensors = this.as_optional_tensors.map((item) => new torch._export.serde.schema.OptionalTensorArgument(item));
                 } else {
                     throw new python.Error(`Unsupported argument '${this.type}'.`);
                 }
                 /*
-                as_tensors: List[TensorArgument]
-                as_string: str
-                as_strings: List[str]
-                as_sym_int: SymIntArgument
-                as_sym_ints: List[SymIntArgument]
-                as_scalar_type: ScalarType
-                as_memory_format: MemoryFormat
-                as_layout: Layout
-                as_bools: List[bool]
                 as_sym_bool: SymBoolArgument
                 as_sym_bools: List[SymBoolArgument]
                 as_graph: GraphArgument
-                as_optional_tensors: List[OptionalTensorArgument]
                 as_custom_obj: CustomObjArgument
                 */
             }
@@ -17711,7 +18026,7 @@ python.Execution = class {
         });
         this.registerType('torch._export.serde.schema.BufferMutationSpec', class {
             constructor(obj) {
-                this.arg = new torch._export.serde.schema.Argument(obj.arg);
+                this.arg = new torch._export.serde.schema.TensorArgument(obj.arg);
                 this.buffer_name = obj.buffer_name;
             }
         });
@@ -17768,6 +18083,12 @@ python.Execution = class {
                 this.name = obj.name;
             }
         });
+        this.registerType('torch._export.serde.schema.GraphArgument', class {
+            constructor(obj) {
+                this.name = obj.name;
+                this.graph = new torch._export.serde.schema.Graph(obj.graph);
+            }
+        });
         this.registerType('torch._export.serde.schema.OptionalTensorArgument', class extends torch._export.serde.union._Union {
             constructor(obj) {
                 super(obj);
@@ -17780,13 +18101,22 @@ python.Execution = class {
                 }
             }
         });
-        this.registerFunction('torch._export.load', (f, expected_opset_version) => {
-            const serialized_exported_program = f.get('serialized_exported_program.json');
-            const serialized_state_dict = f.get('serialized_state_dict.pt');
-            const serialized_constants = f.get('serialized_constants.pt');
-            const serialized_example_inputs = f.get('serialized_example_inputs.pt');
-            const artifact = new torch._export.serde.serialize.SerializedArtifact(serialized_exported_program, serialized_state_dict, serialized_constants, serialized_example_inputs);
-            return torch._export.serde.serialize.deserialize(artifact, expected_opset_version);
+        this.registerFunction('torch.export.pt2_archive._package.load_pt2', (f, expected_opset_version) => {
+            const exported_programs = new Map();
+            for (const name of f.keys()) {
+                const match = name.match(/^models\/([^/]+)\.json$/);
+                if (match) {
+                    const [, model_name] = match;
+                    const serialized_exported_program = f.get(`models/${model_name}.json`);
+                    const serialized_state_dict = f.get(`data/weights/${model_name}.pt`);
+                    const serialized_constants = f.get(`data/constants/${model_name}.pt`);
+                    const serialized_example_inputs = f.get(`data/sample_inputs/${model_name}.pt`);
+                    const artifact = new torch._export.serde.serialize.SerializedArtifact(serialized_exported_program, serialized_state_dict, serialized_constants, serialized_example_inputs);
+                    const exported_program = torch._export.serde.serialize.deserialize(artifact, expected_opset_version);
+                    exported_programs.set(model_name, exported_program);
+                }
+            }
+            return { exported_programs };
         });
         this.registerFunction('torch._export.serde.serialize._dict_to_dataclass', (cls, data) => {
             if (data === null) {
@@ -18427,10 +18757,23 @@ python.Execution = class {
         this.registerType('torch._dynamo.convert_frame.CatchErrorsWrapper', class {});
         this.registerType('torch._dynamo.convert_frame.ConvertFrameAssert', class {});
         this.registerType('torch._dynamo.convert_frame.ConvertFrame', class {});
+        this.registerType('torch._dynamo.convert_frame.ConvertFrameBox', class {});
         this.registerType('torch._dynamo.eval_frame._TorchDynamoContext', class {});
-        this.registerType('torch._dynamo.eval_frame.OptimizedModule', class extends torch.nn.modules.module.Module {});
+        this.registerType('torch._dynamo.eval_frame.OptimizedModule', class extends torch.nn.modules.module.Module {
+            constructor(mod, dynamo_ctx) {
+                builtins.object.__setattr__(self, '_orig_mod', mod);
+                // this._super_module_initialized = false;
+                super();
+                // this._super_module_initialized = true;
+                this._orig_mod = mod;
+                this.dynamo_ctx = dynamo_ctx;
+                // this._initialize();
+                this.training = this._orig_mod.training;
+            }
+        });
         this.registerType('torch._dynamo.eval_frame.OptimizeContext', class extends torch._dynamo.eval_frame._TorchDynamoContext {});
         this.registerType('torch._dynamo.hooks.Hooks', class {});
+        this.registerType('torch._dynamo.output_graph.GraphCompileReason', class {});
         this.registerType('torch._dynamo.repro.after_dynamo.WrapBackendDebug', class {});
         this.registerType('torch._TorchCompileInductorWrapper', class {});
         this.registerFunction('torch._inductor.compile_fx.compile_fx');
@@ -18556,7 +18899,7 @@ python.Execution = class {
             _set_cdata(data) {
                 const length = this.size() * this.dtype.itemsize();
                 if (length !== data.length) {
-                    throw new python.Error('Storage data size mismatch.');
+                    throw new python.Error('Typed storage data size mismatch.');
                 }
                 this._cdata = data;
             }
@@ -18564,7 +18907,7 @@ python.Execution = class {
                 const buffer = unpickler.read(8);
                 const size = buffer.reverse().reduce((a, b) => (a * 256) + b, 0);
                 if (size !== this.size()) {
-                    throw new python.Error('Storage size mismatch.');
+                    throw new python.Error('Typed storage size mismatch.');
                 }
                 const itemsize = this.dtype.itemsize();
                 const data = unpickler.stream(itemsize * size);
@@ -18580,19 +18923,28 @@ python.Execution = class {
                 return storage;
             }
         });
-        this.registerType('torch.storage.UntypedStorage', class extends torch.storage._StorageBase {
-            constructor() {
-                super();
-                throw new python.Error('UntypedStorage not implemented.');
+        this.registerType('torch.storage.UntypedStorage', class {
+            constructor(size) {
+                this._size = size;
+            }
+            _set_cdata(data) {
+                if (this._size !== data.length) {
+                    throw new python.Error('Untyped storage data size mismatch.');
+                }
+                this._cdata = data;
             }
         });
         this.registerType('torch.storage.TypedStorage', class {
             constructor(...args) {
-                if (args.length >= 2 && Number.isInteger(args[0]) && args[1] instanceof torch.dtype) {
+                if (args.length === 0) {
+                    this._size = 0;
+                } else if (args.length === 1 && Number.isInteger(args[0])) {
+                    [this._size] = args;
+                } else if (args.length >= 2 && Number.isInteger(args[0]) && args[1] instanceof torch.dtype) {
                     if (args[3] instanceof torch.device) {
-                        [this._size, this._dtype, , this._device] = args;
+                        [this._size, this.dtype, , this._device] = args;
                     } else {
-                        [this._size, this._dtype] = args;
+                        [this._size, this.dtype] = args;
                     }
                 } else {
                     throw new python.Error(`Unsupported TypedStorage arguments '${JSON.stringify(args)}'.`);
@@ -18604,6 +18956,9 @@ python.Execution = class {
             get dtype() {
                 return this._dtype;
             }
+            set dtype(value) {
+                this._dtype = value;
+            }
             element_size() {
                 return this._dtype.element_size;
             }
@@ -18641,89 +18996,101 @@ python.Execution = class {
             }
         });
         this.registerType('torch.storage._LegacyStorage', class extends torch.storage.TypedStorage {
-            constructor() {
-                super();
-                throw new python.Error('_LegacyStorage not implemented.');
-            }
         });
-        this.registerType('torch.BoolStorage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.bool);
+        this.registerType('torch.BoolStorage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.bool;
             }
         });
-        this.registerType('torch.ByteStorage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.uint8);
+        this.registerType('torch.ByteStorage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.uint8;
             }
         });
-        this.registerType('torch.CharStorage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.int8);
+        this.registerType('torch.CharStorage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.int8;
             }
         });
-        this.registerType('torch.ShortStorage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.int16);
+        this.registerType('torch.ShortStorage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.int16;
             }
         });
-        this.registerType('torch.IntStorage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.int32);
+        this.registerType('torch.IntStorage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.int32;
             }
         });
-        this.registerType('torch.LongStorage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.int64);
+        this.registerType('torch.LongStorage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.int64;
             }
         });
-        this.registerType('torch.HalfStorage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.float16);
+        this.registerType('torch.HalfStorage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.float16;
             }
         });
-        this.registerType('torch.FloatStorage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.float32);
+        this.registerType('torch.FloatStorage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.float32;
             }
         });
-        this.registerType('torch.DoubleStorage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.float64);
+        this.registerType('torch.DoubleStorage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.float64;
             }
         });
-        this.registerType('torch.ComplexHalfStorage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.complex32);
+        this.registerType('torch.ComplexHalfStorage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.complex32;
             }
         });
-        this.registerType('torch.ComplexFloatStorage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.complex64);
+        this.registerType('torch.ComplexFloatStorage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.complex64;
             }
         });
-        this.registerType('torch.ComplexDoubleStorage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.complex128);
+        this.registerType('torch.ComplexDoubleStorage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.complex128;
             }
         });
-        this.registerType('torch.QInt8Storage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.qint8);
+        this.registerType('torch.QInt8Storage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.qint8;
             }
         });
-        this.registerType('torch.QUInt8Storage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.quint8);
+        this.registerType('torch.QUInt8Storage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.quint8;
             }
         });
-        this.registerType('torch.QInt32Storage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.qint32);
+        this.registerType('torch.QInt32Storage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.qint32;
             }
         });
-        this.registerType('torch.BFloat16Storage', class extends torch.storage._StorageBase {
-            constructor(size) {
-                super(size, torch.bfloat16);
+        this.registerType('torch.BFloat16Storage', class extends torch.storage._LegacyStorage {
+            constructor(...args) {
+                super(...args);
+                this.dtype = torch.bfloat16;
             }
         });
         this.registerType('torch.Size', class extends Array {
@@ -18737,16 +19104,42 @@ python.Execution = class {
                 return this.length;
             }
         });
-        this.registerType('torch.Tensor', class {
-            constructor() {
-                this._layout = torch.strided;
+        this.registerType('torch._C.TensorMeta', class {
+        });
+        this.registerType('torch._C.TensorBase', class extends torch._C.TensorMeta {
+        });
+        this.registerType('torch.Tensor', class extends torch._C.TensorBase {
+            constructor(storage, shape, dtype, layout, device, requires_grad) {
+                super();
+                if (storage) {
+                    this._storage = storage;
+                }
+                if (shape !== null && shape !== undefined) {
+                    this._shape = shape;
+                }
+                if (dtype) {
+                    this._dtype = dtype;
+                }
+                this._layout = layout || torch.strided;
+                if (device) {
+                    this._device = device;
+                }
+                if (requires_grad !== undefined) {
+                    this.requires_grad = requires_grad;
+                }
             }
             get device() {
+                if (this._device !== undefined) {
+                    return this._device;
+                }
                 return this.storage().device;
             }
             get dtype() {
+                if (this._dtype !== undefined) {
+                    return this._dtype;
+                }
                 if (this._layout === torch.sparse_coo) {
-                    return this._values.dtype();
+                    return this._values.dtype;
                 }
                 return this.storage().dtype;
             }
@@ -18813,6 +19206,12 @@ python.Execution = class {
                         throw new python.Error(`Unsupported tensor state length '${state.length}'.`);
                 }
             }
+            set_(source, storage_offset, size, stride) {
+                this._storage = source;
+                this._storage_offset = storage_offset;
+                this._shape = size;
+                this._stride = stride;
+            }
             __bool__() {
                 return true;
             }
@@ -18839,6 +19238,11 @@ python.Execution = class {
             __str__() {
                 return 'tensor(...)';
             }
+            static _make_wrapper_subclass(cls, size, stride, dtype, storage_offset, layout, device, requires_grad) {
+                const t = new torch.Tensor(null, size, dtype, layout, device, requires_grad);
+                t.__setstate__([null, storage_offset, size, stride]);
+                return t;
+            }
         });
         this.registerType('torch.nn.parameter.Parameter', class extends torch.Tensor {
             constructor(data, requires_grad) {
@@ -18874,6 +19278,13 @@ python.Execution = class {
         this.registerType('torch.cuda.DoubleStorage', class extends torch.cuda._CudaLegacyStorage {});
         this.registerType('torch.cuda.DoubleTensor', class extends torch.Tensor {});
         this.registerType('torch.cuda.amp.grad_scaler.GradScaler', class {});
+        this.registerType('torchao.utils.TorchAOBaseTensor', class extends torch.Tensor {});
+        this.registerType('torchao.dtypes.affine_quantized_tensor.AffineQuantizedTensor', class extends torchao.utils.TorchAOBaseTensor {});
+        this.registerType('torchao.dtypes.utils.Layout', class {});
+        this.registerType('torchao.dtypes.floatx.float8_layout.Float8Layout', class extends torchao.dtypes.utils.Layout {});
+        this.registerType('torchao.dtypes.utils.AQTTensorImpl', class extends torchao.utils.TorchAOBaseTensor {});
+        this.registerType('torchao.dtypes.floatx.float8_layout.Float8AQTTensorImpl', class extends torchao.dtypes.utils.AQTTensorImpl {});
+        this.registerType('torchao.quantization.quant_primitives.ZeroPointDomain', class extends this.enum.Enum {});
         this.registerFunction('torch.cuda.amp.grad_scaler._refresh_per_optimizer_state');
         this.registerType('torch.SymBool', class {
             constructor(node) {
@@ -18977,7 +19388,7 @@ python.Execution = class {
         this.registerType('fastai.basic_train.Recorder', class {});
         this.registerFunction('fastai.torch_core._fa_rebuild_tensor', (cls, ...args) => {
             const tensor = torch._utils._rebuild_tensor_v2(...args);
-            return self.invoke(cls, tensor);
+            return self.invoke(cls, [tensor]);
         });
         this.registerFunction('fastai.torch_core.trainable_params');
         this.registerFunction('fastai.torch_core._rebuild_from_type', (func, type, args, dict) => {
@@ -19000,7 +19411,7 @@ python.Execution = class {
         this.registerFunction('fastai.torch_core.uniform');
         this.registerType('fastai.callback.core.Callback', class extends fastcore.basics.GetAttr {});
         this.registerType('fastai.callback.core.TrainEvalCallback', class extends fastai.callback.core.Callback {});
-        this.registerType('fastai.callback.fp16.AMPMode', class extends this._enum.Enum {});
+        this.registerType('fastai.callback.fp16.AMPMode', class extends this.enum.Enum {});
         this.registerType('fastai.callback.fp16.MixedPrecision', class {});
         this.registerFunction('fastai.callback.hook._hook_inner');
         this.registerType('fastai.callback.hook.Hook', class extends builtins.object {});
@@ -19101,6 +19512,7 @@ python.Execution = class {
         this.registerType('fastai.vision.augment.Brightness', class {});
         this.registerType('fastai.vision.augment.flip_mat', class {});
         this.registerType('fastai.vision.augment.Flip', class {});
+        this.registerType('fastai.vision.augment.RandomResizedCrop', class {});
         this.registerType('fastai.vision.augment.RandomResizedCropGPU', class {});
         this.registerType('fastai.vision.augment.Resize', class {});
         this.registerType('fastai.vision.augment.rotate_mat', class {});
@@ -19400,7 +19812,9 @@ python.Execution = class {
             return this.expression(stmt.value, context);
         } else if (stmt instanceof ast.FunctionDef) {
             const module = context.get('__name__');
+            /* eslint-disable consistent-this */
             const self = this;
+            /* eslint-enable consistent-this */
             const parent = context.get('__class__');
             const type = (parent === builtins.module) ? builtins.function : builtins.method;
             const func = {
@@ -19415,7 +19829,7 @@ python.Execution = class {
             };
             context.set(stmt.name, func);
         } else if (stmt instanceof ast.ClassDef) {
-            const bases = stmt.bases.map((base) => this.expression(base, context));
+            const bases = stmt.bases.map((base) => this.base(base, context));
             if (bases.length > 1) {
                 throw new python.Error(`Unsupported multiple bases for class '${stmt.name}'.`);
             }
@@ -19682,6 +20096,10 @@ python.Execution = class {
         return undefined;
     }
 
+    base(expr, context) {
+        return this.expression(expr, context);
+    }
+
     identifier(expr) {
         const ast = this.ast;
         if (expr instanceof ast.Name) {