Method __update_args_kwargs

source/python.js:8888–8927

(new_args, new_kwargs)

                [p._next, n._prev] = [n, p];
            }
            __update_args_kwargs(new_args, new_kwargs) {
                const update_users_and_input_nodes = (n) => {
                    if (n instanceof torch.fx.node.Node) {
                        this._input_nodes.setdefault(n);
                        n.users.setdefault(this);
                    }
                    return n;
                };
                const map_aggregate = (a, fn) => {
                    if (a instanceof builtins.tuple) {
                        const t = new builtins.tuple(a.map((elem) => map_aggregate(elem, fn)));
                        if (!builtins.hasattr(a, '_fields')) {
                            return t;
                        }
                        throw new python.Error('Not implemented.');
                        // return type(a)(*t);
                    } else if (Array.isArray(a)) {
                        return a.map((elem) => map_aggregate(elem, fn));
                    } else if (a instanceof builtins.dict) {
                        const rv = new builtins.dict();
                        for (const [k, v] of a) {
                            rv.__setitem__(k, map_aggregate(v, fn));
                        }
                        return rv;
                    } else if (a instanceof builtins.slice) {
                        throw new python.Error('Not implemented.');
                        // return slice(map_aggregate(a.start, fn), map_aggregate(a.stop, fn), map_aggregate(a.step, fn))
                    }
                    return fn(a);
                };
                for (const old_use of this._input_nodes.keys()) {
                    old_use.users.pop(this);
                }
                // object.__setattr__(self, "_input_nodes", {})
                this._input_nodes = new builtins.dict();
                // object.__setattr__(self, "_args", map_aggregate(new_args, update_users_and_input_nodes))
                this._args = map_aggregate(new_args, update_users_and_input_nodes);
                // object.__setattr__(self, "_kwargs", map_aggregate(new_kwargs, update_users_and_input_nodes))
                this._kwargs = map_aggregate(new_kwargs, update_users_and_input_nodes);
            }
        });
        torch.fx.Node = torch.fx.node.Node;
        torch.fx.graph.Node = torch.fx.node.Node;