Method deserialize_multiple_outputs

source/python.js:20379–20460

(serialized_node, fx_node)

                this.deserialize_multiple_outputs(serialized_node, fx_node);
            }
            deserialize_multiple_outputs(serialized_node, fx_node) {
                const deserialized_metadata = this.deserialize_metadata(serialized_node.metadata);
                const generate_getitem = (meta_val, fx_node, arg, idx) => {
                    let name = '';
                    if (arg instanceof torch._export.serde.schema.TensorArgument) {
                        name = arg.name;
                    } else if (arg instanceof torch._export.serde.schema.SymIntArgument) {
                        name = arg.as_name;
                    } else if (arg instanceof torch._export.serde.schema.SymFloatArgument) {
                        name = arg.as_name;
                    } else {
                        throw new python.Error(`Unsupported argument type '${arg}'.`);
                    }
                    const individual_output = this.graph.create_node(
                        'call_function',
                        operator.getitem,
                        new builtins.tuple([fx_node, idx]),
                        null,
                        name,
                    );
                    this.sync_fx_node(name, individual_output);
                    meta_val.push(this.serialized_name_to_meta.get(name));
                    individual_output.meta.update(deserialized_metadata);
                };
                const generate_getitems = (meta_val, fx_node, args) => {
                    for (let idx = 0; idx < args.length; idx++) {
                        const arg = args[idx];
                        if (arg instanceof torch._export.serde.schema.TensorArgument ||
                            arg instanceof torch._export.serde.schema.SymIntArgument ||
                            arg instanceof torch._export.serde.schema.SymFloatArgument) {
                            generate_getitem(meta_val, fx_node, arg, idx);
                        } else if (arg instanceof torch._export.serde.schema.Argument) {
                            if (arg.type === 'as_tensor' || arg.type === 'as_sym_int' || arg.type === 'as_sym_float') {
                                generate_getitem(meta_val, fx_node, arg.value, idx);
                            } else if (arg.type === 'as_none') {
                                const individual_output = this.graph.create_node(
                                    'call_function',
                                    operator.getitem,
                                    new builtins.tuple([fx_node, idx]),
                                    null,
                                    'as_none',
                                );
                                meta_val.push(null);
                                individual_output.meta.set('val', null);
                                individual_output.meta.update(deserialized_metadata);
                            } else if (Array.isArray(arg.value)) {
                                const list_output = this.graph.create_node(
                                    'call_function',
                                    operator.getitem,
                                    new builtins.tuple([fx_node, idx]),
                                );
                                meta_val.push([]);
                                generate_getitems(meta_val[meta_val.length - 1], list_output, arg.value);
                                list_output.meta.update(deserialized_metadata);
                                list_output.meta.set('val', meta_val[meta_val.length - 1]);
                            } else {
                                throw new python.Error(`Unsupported node output type '${arg.type}'.`);
                            }