Method importEnum

source/python.js:13844–13885

(qualified_name, enum_def)

                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, 'String');
                            set_or_check_type(torch.StringType.get());
                            break;
                        case 'int':
                            ivalue = new torch._C.IValue(rhs.value, 'Int');
                            set_or_check_type(torch.IntType.get());
                            break;
                        case 'float':
                            ivalue = new torch._C.IValue(rhs.value, 'Double');
                            set_or_check_type(torch.FloatType.get());
                            break;
                        default:
                            throw new python.Error(`Unsupported enum value type '${rhs.type}'.`);
                    }
                    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 = [];