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

qairt_visualizer/core/ui/dist/browser/node.js

@@ -0,0 +1,102 @@
+
+import * as fs from 'fs';
+
+const node = {};
+
+node.FileStream = class {
+
+    constructor(file, start, length, mtime) {
+        this._file = file;
+        this._start = start;
+        this._length = length;
+        this._position = 0;
+        this._mtime = mtime;
+    }
+
+    get position() {
+        return this._position;
+    }
+
+    get length() {
+        return this._length;
+    }
+
+    stream(length) {
+        const stream = new node.FileStream(this._file, this._start + this._position, length, this._mtime);
+        this.skip(length);
+        return stream;
+    }
+
+    seek(position) {
+        this._position = position >= 0 ? position : this._length + position;
+    }
+
+    skip(offset) {
+        this._position += offset;
+        if (this._position > this._length) {
+            const offset = this._position - this._length;
+            throw new Error(`Expected ${offset} more bytes. The file might be corrupted. Unexpected end of file.`);
+        }
+    }
+
+    peek(length) {
+        length = length === undefined ? this._length - this._position : length;
+        if (length < 0x1000000) {
+            const position = this._fill(length);
+            this._position -= length;
+            return this._buffer.subarray(position, position + length);
+        }
+        const position = this._position;
+        this.skip(length);
+        this.seek(position);
+        const buffer = new Uint8Array(length);
+        this._read(buffer, position);
+        return buffer;
+    }
+
+    read(length) {
+        length = length === undefined ? this._length - this._position : length;
+        if (length < 0x10000000) {
+            const position = this._fill(length);
+            return this._buffer.slice(position, position + length);
+        }
+        const position = this._position;
+        this.skip(length);
+        const buffer = new Uint8Array(length);
+        this._read(buffer, position);
+        return buffer;
+    }
+
+    _fill(length) {
+        if (this._position + length > this._length) {
+            const offset = this._position + length - this._length;
+            throw new Error(`Expected ${offset} more bytes. The file might be corrupted. Unexpected end of file.`);
+        }
+        if (!this._buffer || this._position < this._offset || this._position + length > this._offset + this._buffer.length) {
+            this._offset = this._position;
+            const length = Math.min(0x10000000, this._length - this._offset);
+            if (!this._buffer || length !== this._buffer.length) {
+                this._buffer = new Uint8Array(length);
+            }
+            this._read(this._buffer, this._offset);
+        }
+        const position = this._position;
+        this._position += length;
+        return position - this._offset;
+    }
+
+    _read(buffer, offset) {
+        const descriptor = fs.openSync(this._file, 'r');
+        const stat = fs.statSync(this._file);
+        if (stat.mtimeMs !== this._mtime) {
+            throw new Error(`File '${this._file}' last modified time changed.`);
+        }
+        try {
+            fs.readSync(descriptor, buffer, 0, buffer.length, offset + this._start);
+        } finally {
+            fs.closeSync(descriptor);
+        }
+    }
+};
+
+export const FileStream = node.FileStream;

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

@@ -22,13 +22,13 @@ numpy.ModelFactory = class {
 
     async open(context) {
         let format = '';
-        const graphs = [];
+        const modules = [];
         switch (context.type) {
             case 'npy': {
                 format = 'NumPy Array';
                 const unresolved = new Set();
                 const execution = new python.Execution();
-                execution.on('resolve', (_, name) => unresolved.add(name));
+                execution.on('resolve', (sender, name) => unresolved.add(name));
                 const stream = context.stream;
                 const bytes = execution.invoke('io.BytesIO', [stream]);
                 const array = execution.invoke('numpy.load', [bytes]);
@@ -37,11 +37,11 @@ numpy.ModelFactory = class {
                     throw new numpy.Error(`Unknown type name '${name}'.`);
                 }
                 const layer = { type: 'numpy.ndarray', parameters: [{ name: 'value', tensor: { name: '', array } }] };
-                graphs.push({ layers: [layer] });
+                modules.push({ layers: [layer] });
                 break;
             }
             case 'npz': {
-                format = 'NumPy Zip';
+                format = 'NumPy Archive';
                 const layers = new Map();
                 const entries = Array.from(context.value);
                 const separator = entries.every(([name]) => name.endsWith('.weight.npy')) ? '.' : '/';
@@ -59,26 +59,26 @@ numpy.ModelFactory = class {
                         tensor: { name, array }
                     });
                 }
-                graphs.push({ layers: Array.from(layers.values()) });
+                modules.push({ layers: Array.from(layers.values()) });
                 break;
             }
             default: {
                 throw new numpy.Error(`Unsupported NumPy format '${context.type}'.`);
             }
         }
-        return new numpy.Model(format, graphs);
+        return new numpy.Model(format, modules);
     }
 };
 
 numpy.Model = class {
 
-    constructor(format, graphs) {
+    constructor(format, modules) {
         this.format = format;
-        this.graphs = graphs.map((graph) => new numpy.Graph(graph));
+        this.modules = modules.map((module) => new numpy.Module(module));
     }
 };
 
-numpy.Graph = class {
+numpy.Module = class {
 
     constructor(graph) {
         this.name = graph.name || '';

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

@@ -35,7 +35,7 @@ om.Model = class {
             signature: target.signature,
             weights: target.weights
         };
-        this.graphs = target.model.graph.map((graph) => new om.Graph(context, graph));
+        this.modules = target.model.graph.map((graph) => new om.Graph(context, graph));
     }
 };
 
@@ -193,7 +193,7 @@ om.Node = class {
                 case 's': {
                     if (typeof obj.s === 'string') {
                         value = obj.s;
-                    } else if (obj.s.filter((c) => c <= 32 && c >= 128).length === 0) {
+                    } else if (obj.s.every((c) => c >= 32 && c <= 128)) {
                         value = om.Utility.decodeText(obj.s);
                     } else {
                         value = obj.s;

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

@@ -23,7 +23,7 @@ onednn.Model = class {
         const version = symbol.version;
         this.format = `oneDNN${version ? ` v${version}` : ''}`;
         this.runtime = `${symbol.engine_kind} ${symbol.fpmath_mode}`;
-        this.graphs = [new onednn.Graph(metadata, symbol)];
+        this.modules = [new onednn.Graph(metadata, symbol)];
     }
 };