depyo 1.0.0

package/lib/PycResult.js

@@ -0,0 +1,82 @@
+class PycResult {
+    result = [];
+    indent = 0;
+    doNotIndent = false;
+    
+    constructor(lines, doNotIndent = false) {
+        if (lines) {
+            this.add(lines);
+        }
+        this.doNotIndent = doNotIndent;
+    }
+    
+    get length() {
+        return this.result.length;
+    }
+
+    get last() {
+        return this.result[this.result.length - 1];
+    }
+
+    get hasResult() { 
+        return this.result.length > 1 || (this.result.length == 1 && this.result[0].length > 0);
+    }
+    
+    increaseIndent() {
+        this.indent++;
+    }
+    
+    decreaseIndent() {
+        if (this.indent > 0) {
+            this.indent--;
+        }
+    }
+    
+    clear() {
+        this.indent = 0;
+        this.result = [];
+    }
+
+    add(line) {
+        let padding = " ".repeat(4 * this.indent);
+        let lines = [];
+
+        if (line instanceof PycResult) {
+            if (!line.doNotIndent) {
+                padding = " ".repeat(4 * (this.indent + 1));
+            }
+            lines = line.result;
+        } else {
+            lines.push(line)
+        }
+
+        for (line of lines) {
+            this.result.push(padding + line);
+        }
+    }
+
+    lastLineAppend(data, shouldTrim = true) {
+        if (this.result.length == 0) {
+            this.result.push("");
+        }
+        if (data.constructor.name == "String") {
+            this.result[this.result.length - 1] += shouldTrim ? data.trim() : data;
+        } else {
+            let str = data?.result?.shift();
+            this.result[this.result.length - 1] += shouldTrim? str.trim() : str;
+            this.add(data);
+        }
+    }
+
+    chop(suffix) {
+        if (this.last.endsWith(suffix)) {
+            this.result[this.result.length - 1] = this.last.substring(0,this.last.length - suffix.length);
+        }
+    }
+
+    toString() {
+        return this.result.join("\n");
+    }
+}
+
+module.exports = PycResult;

package/lib/PythonObject.js

@@ -0,0 +1,242 @@
+class PythonObject {
+    ClassName = null;
+    Value = null;
+
+    constructor(class_name, value) {
+        this.ClassName = class_name || null;
+        this.Value = value || null;
+    }
+
+    add(po) {
+        if (["Py_List", "Py_Tuple", "Py_Set", "Py_FrozenSet"].includes(this.ClassName))
+        {
+            let list = this.Value;
+
+            if (list == null) {
+                list = [];
+                this.Value = list;
+            }
+
+            list.push(po);
+        }
+    }
+
+    add(key, val) {
+        if (this.ClassName == "Py_Dict") {
+            let dict = this.Value;
+            if (dict == null)
+            {
+                dict = [];
+                this.Value = dict;
+            }
+
+            dict.push({key, value: val});
+        }
+    }
+
+    get length() {
+        if (["Py_String", "Py_List", "Py_Dict", "Py_Tuple", "Py_Set", "Py_FrozenSet", "Py_VeryLong"].includes(this.ClassName)) {
+            if (this.Value && this.Value.length) {
+                return this.Value.length;
+            } else {
+                return 0;
+            }
+        } else {
+            return 1;
+        }
+    }
+
+    // TODO: Refactor to use Symbol.toPrimitive() and Object.valueOf()
+
+    toString()
+    {
+        switch(this.ClassName) {
+            case "Py_Unicode":
+            case "Py_String":
+                let strValue = this.Value;
+                if (strValue.ClassName) {
+                    throw new SyntaxError("Recursion");
+                }
+                if (!strValue || strValue.length == 0) {
+                    return "";
+                }
+                strValue = strValue.toString();
+                if (strValue.includes("\n")) {
+                    strValue = strValue.replaceAll("\n", "\\n");
+                }
+                return strValue;
+
+            case "Py_Int":
+            case "Py_Long":
+            case "Py_Long64":
+                return this.Value !== null ? this.Value.toString() : "0";
+
+            case "Py_Interned":
+                return this.Value !== null ? this.Value.toString() : "0";
+
+            case "Py_Float":
+                return this.Value !== null ? `${this.Value}${Number.isInteger(this.Value) ? ".0" : ""}` : "0.0";
+
+            case "Py_VeryLong":
+                if (this.Value) {
+                    if (this.Value.length < 8) {
+                        return this.Value.toString();
+                    } else {
+                        let result = "0x";
+                        let skipFirstZeros = true;
+                        let shortFlag = true;
+                        for (let idx = this.Value.length - 1; idx >= 0; idx--) {
+                            let value = this.Value[idx];
+                            value = value.toString(16);
+                            if (skipFirstZeros && value == 0) {
+                                continue;
+                            } else if (skipFirstZeros && value) {
+                                skipFirstZeros = false;
+                            }
+                            if (!shortFlag) {
+                                value = value.length < 2 ? "0" + value : value;
+                            }
+                            shortFlag = false;
+                            result += value;
+                        }
+                        return result;
+                    }
+                } else {
+                    return "0";
+                }
+
+            case "Py_Null":
+                return "None";
+
+            case "Py_False":
+                return "False";
+
+            case "Py_True":
+                return "True";
+
+            case "Py_None":
+                return "None";
+
+            case "Py_Tuple":
+            case "Py_Set":
+            case "Py_FrozenSet":
+                let res = "(";
+                if (this.Value) {
+                    for (let obj of this.Value) {
+                        if (res != "(") {
+                            res += ", " + obj;
+                        } else {
+                            res += obj;
+                        }
+                    }
+                    res += ")";
+                    return res;
+                } else {
+                    return "null";
+                }
+
+            case "Py_CodeObject":
+                return `<code object ${this.Name.toString()}, file '${this.FileName.toString()}', line ${this.FirstLineNo}>`;
+
+            case "Py_Dict":
+                if (this.Value) {
+                    let res = "(";
+                    for (let pair of this.Value) {
+                        if (res != "(") {
+                            res += ", ";
+                        } 
+                        res += pair.key + ": " + pair.value;
+                    }
+                    res += ")";
+                    return res;
+                } else {
+                    return "()";
+                }
+
+            case "Py_StringRef":
+                return this.Strings[this.Value];
+
+            case "Py_Complex":
+                return `${this.Value[0]}+${this.Value[1]}j`;
+    
+            default:
+                return ["Py_String"].includes(this.ClassName) ? this.Value.toString("ascii") : null;
+        }
+    }
+}
+
+class PythonCodeObject extends PythonObject {
+    ClassName = "Py_CodeObject";
+    ArgCount = 0;
+    PosOnlyArgCount = 0;
+    KWOnlyArgCount = 0;
+    NumLocals = 0;
+    StackSize = 0;
+    Flags = 0;
+    Code = null;
+    Consts = [];
+    Names = [];
+    VarNames = [];
+    FreeVars = [];
+    CellVars = [];
+    FileName = null;
+    Name = null;
+    FirstLineNo = 0;
+    LineNoTab = [];
+    LineNoTabObject = null;
+    ExceptionTable = null;  // Python 3.11+ exception table (raw bytes or parsed entries)
+    Methods = [];
+    SourceCode = null;
+    FuncParams = null;
+    FuncDecos = null;
+    FuncName = null;
+    ASTTree = [];
+    Globals = new Set();
+    CachedLineNo = -1;
+
+    getLineNumber(offset, isVer310 = false) {
+        if (offset < 0) {
+            return this.FirstLineNo;
+        }
+
+        if (this.CachedLineNo > -1) {
+            return this.CachedLineNo;
+        }
+
+        if (!this.LineNoTabObject || this.LineNoTabObject.Value.length < 2 || offset >= this.Code.length) {
+            return -1;
+        }
+
+        let lnTable = this.LineNoTabObject.Value;
+        let size = lnTable.length / 2;
+        let sDelta = 0;
+        let lDelta = 0;
+
+        let line = this.FirstLineNo;
+        let addr = 0;
+        let index = 0;
+        while (--size >= 0) {
+            sDelta = lnTable[index++];
+            lDelta = lnTable[index++];
+
+            addr += sDelta;
+            if (addr > offset)
+                break;
+
+            if (isVer310 && lDelta == -128) { // Should we treat no line number? or treat it as previous line?
+                lDelta = 0;
+            }
+
+            line += lDelta;
+        }
+        return line;
+    }
+}
+
+
+module.exports = {PythonObject, PythonCodeObject};
+
+// Registering classes in global scope for propoer class deserialization.
+for (let className of Object.keys(module.exports)) {
+    global[className] = new module.exports[className]();
+}

package/lib/Unpickle.js

@@ -0,0 +1,173 @@
+// public class Unpickle
+// {
+//     public static List<object> Load(string fileName)
+//     {
+//         List<object> result = null;
+//         BinaryReader rdr = new BinaryReader(File.OpenRead(fileName));
+
+//         result = Load(rdr);
+
+
+//         return result;
+//     }
+
+//     public static List<object> Load(byte[] data)
+//     {
+//         MemoryStream memStream = new MemoryStream(data);
+//         BinaryReader rdr = new BinaryReader(memStream);
+//         return Load(rdr);
+//     }
+
+//     public static List<object> Load(BinaryReader rdr)
+//     {
+//         List<object> result = new List<object>();
+//         List<object> memo = new List<object>();
+
+//         while (rdr.BaseStream.Position < rdr.BaseStream.Length)
+//         {
+
+//             byte opCode = rdr.ReadByte();
+
+//             switch ((char)opCode)
+//             {
+//                 case '(': // MARK
+//                     break;
+//                 case '.': // STOP
+//                     break;
+//                 case '0': // POP
+//                     break;
+//                 case '1': // POP_MARK
+//                     break;
+//                 case '2': // DUP
+//                     break;
+//                 case 'F': // FLOAT
+//                     break;
+//                 case 'I': // INT
+//                     break;
+//                 case 'J': // BININT
+//                     result.Add(rdr.ReadInt32());
+//                     break;
+//                 case 'K': // BININT1
+//                     result.Add(rdr.ReadByte());
+//                     break;
+//                 case 'L': // LONG
+//                     break;
+//                 case 'M': // BININT2
+//                     result.Add(rdr.ReadInt16());
+//                     break;
+//                 case 'N': // NONE
+//                     break;
+//                 case 'P': // PERSID
+//                     rdr.ReadByte();
+//                     break;
+//                 case 'Q': // BINPERSID
+//                     break;
+//                 case 'R': // REDUCE
+//                     break;
+//                 case 'S': // STRING
+//                     break;
+//                 case 'T': // BINSTRING
+//                     int size = rdr.ReadInt32();
+//                     result.Add(rdr.ReadBytes(size));
+//                     break;
+//                 case 'U': // SHORT_BINSTRING
+//                     int uSize = (int)rdr.ReadByte();
+//                     result.Add(rdr.ReadBytes(uSize));
+//                     break;
+//                 case 'V': // UNICODE
+//                     break;
+//                 case 'X': // BINUNICODE
+//                     uSize = (int)rdr.ReadByte();
+//                     result.Add(rdr.ReadBytes(uSize));
+//                     break;
+//                 case 'a': // APPEND
+//                     break;
+//                 case 'b': // BUILD
+//                     break;
+//                 case 'c': // GLOBAL
+//                     break;
+//                 case 'd': // DICT
+//                     break;
+//                 case '}': // EMPTY_DICT
+//                     break;
+//                 case 'e': // APPENDS
+//                     break;
+//                 case 'g': // GET
+//                     break;
+//                 case 'h': // BINGET
+//                     int idx = rdr.ReadByte();
+//                     if (idx < memo.Count)
+//                         result.Add(memo[idx]);
+//                     break;
+//                 case 'i': // INST
+//                     break;
+//                 case 'j': // LONG_BINGET
+//                     idx = rdr.ReadInt32();
+//                     break;
+//                 case 'l': // LIST
+//                     break;
+//                 case ']': // EMPTY_LIST
+//                     break;
+//                 case 'o': // OBJ
+//                     break;
+//                 case 'p': // PUT
+//                     break;
+//                 case 'q': // BINPUT
+//                     idx = rdr.ReadByte();
+//                     break;
+//                 case 'r': // LONG_BINPUT
+//                     idx = rdr.ReadInt32();
+//                     break;
+//                 case 's': // SETITEM
+//                     break;
+//                 case 't': // TUPLE
+//                     break;
+//                 case ')': // EMPTY_TUPLE
+//                     break;
+//                 case 'u': // SETITEMS
+//                     break;
+//                 case 'G': // BINFLOAT
+//                     result.Add(rdr.ReadDouble());
+//                     break;
+//                 case '\x80': // PROTO
+//                     rdr.ReadByte();
+//                     break;
+//                 case '\x81': // NEWOBJ
+//                     break;
+//                 case '\x82': // EXT1
+//                     break;
+//                 case '\x83': // EXT2
+//                     break;
+//                 case '\x84': // EXT4
+//                     break;
+//                 case '\x85': // TUPLE1
+//                     break;
+//                 case '\x86': // TUPLE2
+//                     break;
+//                 case '\x87': // TUPLE3
+//                     break;
+//                 case '\x88': // NEWTRUE
+//                     result.Add(true);
+//                     break;
+//                 case '\x89': // NEWFALSE
+//                     result.Add(false);
+//                     break;
+//                 case '\x8A': // LONG1
+//                     idx = rdr.ReadByte();
+//                     result.Add(rdr.ReadBytes(idx));
+//                     break;
+//                 case '\x8B': // LONG4
+//                     idx = rdr.ReadInt32();
+//                     result.Add(rdr.ReadBytes(idx));
+//                     break;
+//                 case '\x9D':
+//                     rdr.ReadBytes(1);
+//                     break;
+//                 default:
+//                     throw new ArgumentOutOfRangeException();
+//             }
+//         }
+
+//         return result;
+//     }
+// }