pyui-desktop 0.5.0__tar.gz

pyui_desktop-0.5.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: pyui-desktop
+Version: 0.5.0
+Summary: A short description of my package
+Author-email: Akalabaya Pal <akalabaya.2008@proton.me>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pywebview==6.2.1
+Requires-Dist: watchdog==6.0.0
+Requires-Dist: websockets==16.0
+Requires-Dist: colorama
+Requires-Dist: pyinstaller
+
+# PYUI(Python UI)
+
+This project is targeted to make cross platform applications using python.PYUI is a layout pre-compiled framework for making python applications in very lightweight sizes. It uses a xml layouting system for defining layouts, python for logic and **PYWebview** as the renderer.Leading to a blank application size only 16MB compared to heavyweight rendering systems cosing 50+ MB or TKinter that has very legacy thread-unsafe architecture
+
+## Motivation
+1.**Making General Purpose Applications:** This project is driven by the motivation of making a framework over python that can be used to make general purpose applications with little or no learning curve.
+
+2.**Smaller learning curve:** Recent solutions for UI development mostly are hard to learn and manage. However we adopted age-old xml layouting system that makes defining UI easy for anyone with little xml/html knowlege. 
+
+3.**Support of Python libaries and modules:** On the logic side python can use used to it's Limit, also the threadsafe nature of the framework helps in extreme scalability.
+
+4.**Compiled Layout and Reusibility:** This framework has pre-compiled layouting system.So errors in layout are identified on runtime. Also Layout supports re-usibility using **PYUI Components**.
+
+## Key Features of PYUI API
+1. **DOM Manipulation:** One can change dom components from python side.There style,class,innertext and other attributes.
+
+2. **PYUI Custom Syscalls:** Using this one can extend PYUI to support any JS libaries(chart.js and etc) by writing minimal Javascript.Or can use to commiunicate between JS ans Python runtime if needed without touching internal sockets.
+
+3. **PYUI Hooks:** If some DOM updates are fast and can be lossy but realtime one can use PYUI Hooks.This can be mostly used to stream video or audio from Python to JS runtime
+
+4. **Window Management:** A PYUI forms contain can contain more than one view(window) and **PYUI** provides apis to change windows dynamically. Also Exposes Webview object for *PYwebview* for changing the application window
+
+5. **Forms Management:** **PYUI** provides dedicated apis to show and hide forms.
+
+## Getting Started
+
+
+### Setting up project
+
+    python -m PYUI.create <directory-of-project>
+
+This will generate boilerplate project. Following folder and files will be generated in the given directory.
+
+    layout
+    code
+    layout/JS
+    layout/styles
+    code/index.py
+    code/__init__.py
+    layout/index.xml
+    settings.py
+
+
+### Compiling project
+
+To compile to a PYUI project and run it
+
+    python -m PYUI.buildtools --compile <directory-of-project> --run
+
+This command will compile your project into a PYUI project and run it. Within few seconds(depending on project size) you can see you layout
+
+To compile without running project
+
+    python -m PYUI.buildtools --compile <directory-of-project>
+
+It will save your project in *build/temp_xxxxx.yyyy* (see last line of buildscript output). To launch the project go to the directory and run:
+
+    python bootstrap.py
+
+It will launch your UI
+
+### HotReloading Layouts
+
+You can hot-reload the layout for faster UI development.
+
+    python -m PYUI.buildtools --hotreload <layout-xml-file>
+
+Changing the xml file will reload the UI automatically
+
+**Note:** Use the *--keepontop* flag to keep the UI on top always
+
+For further API references for XML and PYUI check the documentation.
+
+
+## Credits
+
+PyWebview: https://github.com/r0x0r/pywebview
+

pyui_desktop-0.5.0/PYUI/JS/connection.js

@@ -0,0 +1,188 @@
+class PriorityQueue {
+    constructor(initialCapacity = 100) {
+        this.capacity = initialCapacity;
+        this.heap = new Array(this.capacity);
+        this.size = 0;
+    }
+
+    // Insert a new object and check for resize
+    enqueue(priority, obj) {
+        // 1. Check if we need to resize before adding
+        if (this.size === this.capacity) {
+            this.resize();
+        }
+
+        // 2. Insert at the end of the heap
+        const newNode = { priority, object: obj };
+        this.heap[this.size] = newNode;
+
+        // 3. Heapify Up to restore min-heap property
+        this.heapifyUp(this.size);
+        this.size++;
+    }
+
+    // Remove and return the highest priority item (lowest priority number)
+    dequeue() {
+        if (this.size === 0) return null;
+
+        const root = this.heap[0];
+        const lastNode = this.heap[this.size - 1];
+
+        // Move the last element to the root
+        this.heap[0] = lastNode;
+        this.heap[this.size - 1] = null; // Clear reference for garbage collection
+        this.size--;
+
+        // Heapify Down to restore min-heap property
+        if (this.size > 0) {
+            this.heapifyDown(0);
+        }
+
+        return root;
+    }
+
+    // Double the array capacity when full
+    resize() {
+        this.capacity *= 2;
+        const newHeap = new Array(this.capacity);
+
+        // Copy elements over
+        for (let i = 0; i < this.size; i++) {
+            newHeap[i] = this.heap[i];
+        }
+
+        this.heap = newHeap;
+        console.log(`[PriorityQueue] Resized. New capacity: ${this.capacity}`);
+    }
+
+    // Restores heap order going up
+    heapifyUp(index) {
+        while (index > 0) {
+            const parentIndex = Math.floor((index - 1) / 2);
+
+            // If current node's priority is fine, break
+            if (this.heap[index].priority >= this.heap[parentIndex].priority) {
+                break;
+            }
+
+            this.swap(index, parentIndex);
+            index = parentIndex;
+        }
+    }
+
+    // Restores heap order going down
+    heapifyDown(index) {
+        while (2 * index + 1 < this.size) {
+            let smallestChildIndex = 2 * index + 1; // Assume left child is smaller
+            const rightChildIndex = 2 * index + 2;
+
+            // Check if right child exists and has a lower priority number
+            if (
+                rightChildIndex < this.size &&
+                this.heap[rightChildIndex].priority < this.heap[smallestChildIndex].priority
+            ) {
+                smallestChildIndex = rightChildIndex;
+            }
+
+            // If parent is already smaller than the smallest child, we are done
+            if (this.heap[index].priority <= this.heap[smallestChildIndex].priority) {
+                break;
+            }
+
+            this.swap(index, smallestChildIndex);
+            index = smallestChildIndex;
+        }
+    }
+
+    // Helper to swap two nodes in the array
+    swap(i, j) {
+        const temp = this.heap[i];
+        this.heap[i] = this.heap[j];
+        this.heap[j] = temp;
+    }
+
+    peek() {
+        return this.size > 0 ? this.heap[0] : null;
+    }
+
+    isEmpty() {
+        return this.size === 0;
+    }
+}
+
+
+
+
+
+var GLOBAL_SOCKET = null;
+
+
+
+
+function connectSocket(port) {
+
+    socket = new WebSocket('ws://127.0.0.1:' + port.toString());
+    GLOBAL_SOCKET = socket;
+    const handler = new Msghandler(socket);
+    const priority_queue = new PriorityQueue(1000);
+
+
+    // 2. Triggered when the handshake successfully finishes
+    socket.onopen = (event) => {
+        console.log('Connected to Python WebSocket Server!');
+    };
+
+    // 3. Catch and parse incoming messages from Python as JSON objects
+    socket.onmessage = (event) => {
+
+        var data = JSON.parse(event.data);
+        if (data.type == "BATCH_UPDATE") {
+            handler.evaluateMsg(data);
+        }
+        else {
+            priority_queue.enqueue(data.count, data);
+        }
+        
+
+
+    };
+
+    let nextExpectedSequence = 0;
+    //Run loop to dequeue the object and get the object
+    setInterval(() => {
+
+        while (!priority_queue.isEmpty()) {
+            const topItem = priority_queue.peek(); // Just look, don't remove yet!
+
+            // If the top item is exactly what we are waiting for, process it!
+            if (topItem.priority === nextExpectedSequence) {
+                const msg = priority_queue.dequeue();
+
+                handler.evaluateMsg(msg.object); // Run your UI framework logic here
+
+                nextExpectedSequence++; // Move to the next expected number
+            } else {
+                // The next message hasn't arrived from Python yet (there's a gap).
+                // Stop processing and wait for the network/socket to catch up!
+                break;
+            }
+        }
+
+    }, 16);
+
+}
+
+
+
+
+//Console log routing to main python console
+console.log = function () {
+    // Convert arguments to a single string
+    var message = Array.from(arguments).join(' ');
+
+    // Send to Python API
+    if (window.pywebview && window.pywebview.api) {
+        window.pywebview.api.log(message);
+    }
+
+};

pyui_desktop-0.5.0/PYUI/JS/handler.js

@@ -0,0 +1,336 @@
+var SECRET_KEY = null;
+var GLOBAL_CUSTOM_SYSCALL_MAP = {}; // Js object to store all the custom syscalls 
+
+
+function register_sign(sign) {
+    SECRET_KEY = sign;
+}
+
+async function standardSha256(message) {
+    // 1. Encode text string into an array of bytes (UTF-8)
+    const msgBuffer = new TextEncoder().encode(message);
+
+    // 2. Compute the raw SHA-256 hash buffer natively
+    const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
+
+    // 3. Convert the raw binary array buffer into a hex string
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const hashHex = hashArray.map(b => b.toString(16).padStart(2, "0")).join("");
+
+    return hashHex;
+}
+
+
+async function computeHmac(message, secretKey) {
+    const encoder = new TextEncoder();
+
+    // 1. Convert text inputs into byte arrays
+    const messageBytes = encoder.encode(message);
+    const keyBytes = encoder.encode(secretKey);
+
+    // 2. Import the raw secret key into the crypto engine
+    const cryptoKey = await crypto.subtle.importKey(
+        "raw",
+        keyBytes,
+        { name: "HMAC", hash: "SHA-256" },
+        false,
+        ["sign"]
+    );
+
+    // 3. Compute the raw binary signature
+    const signatureBuffer = await crypto.subtle.sign("HMAC", cryptoKey, messageBytes);
+
+    // 4. Convert the binary signature to a standard hexadecimal string
+    const hashArray = Array.from(new Uint8Array(signatureBuffer));
+    return hashArray.map(b => b.toString(16).padStart(2, "0")).join("");
+}
+
+
+async function _HandleCallbackSend(uuid, socket) {
+    //toSend = "{\"uuid\":\"" + uuid + "\",\"type\":\"CALLBACK\",\"data\":\"\"}";
+    toSend = { "uuid": uuid, "type": "CALLBACK", "data": "" };
+
+    send_str = JSON.stringify(toSend);
+
+    //Get the sha-256 encoded string.
+    sha256_encoded_msg = await standardSha256(send_str);
+
+    //make hmac 
+    hmac_code = await computeHmac(sha256_encoded_msg, SECRET_KEY);
+    toSend['sign'] = hmac_code
+
+    socket.send(JSON.stringify(toSend)); //Send the msg back to python runtime
+}
+async function _HandleGrbContent(uuid, socket, value) {
+
+    toSend = { "uuid": uuid, "type": "GRAB_CONTENT", "data": value };
+
+    send_str = JSON.stringify(toSend);
+
+    //Get the sha-256 encoded string.
+    sha256_encoded_msg = await standardSha256(send_str);
+
+    //make hmac 
+    hmac_code = await computeHmac(sha256_encoded_msg, SECRET_KEY);
+    toSend['sign'] = hmac_code
+
+    socket.send(JSON.stringify(toSend)); //Send the msg back to python runtime
+
+}
+
+
+function HandleStyleClass(args) {
+    //args: id,action and class
+    var id = args.id;
+    var action = args.action;
+    var cls = args.class;
+
+    var ele = document.getElementById(id);
+
+    if (ele) {
+        if (action == 'ADD') {
+            ele.classList.add(cls);
+        }
+        else if (action == 'REMOVE') {
+            ele.classList.remove(cls);
+        }
+        else if (action == 'TOGGLE') {
+            ele.classList.toggle(action);
+        }
+    }
+
+
+}
+
+
+async function verifyIncomingMessage(incomingMsg) {
+    // 1. Extract the signature and remove it from the object we want to hash
+    const incomingSig = incomingMsg.sign;
+    delete incomingMsg.sign;
+
+    // 3. Sort keys and flatten (uuid is naturally included now!)
+    const sortedKeys = Object.keys(incomingMsg).sort();
+    let flatString = JSON.stringify(incomingMsg);
+
+    // 4. Hash, compare, and burn
+    const dataHash = await standardSha256(flatString);
+    const expectedSig = await computeHmac(dataHash, SECRET_KEY);
+
+    //console.log(flatString,dataHash);
+
+
+    if (incomingSig !== expectedSig) {
+        return false;
+    }
+
+    return true;
+}
+
+
+//Function for binding JS functions with Python syscall
+async function bind(syscall, callback) {
+
+    //Assign the syscall to GLOBAL CUSTOM SYSCALL MAP
+    GLOBAL_CUSTOM_SYSCALL_MAP[syscall] = callback;
+
+}
+
+function generateUUID() {
+  return ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
+    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
+  );
+}
+
+async function sendSyscall(syscall, msg) {
+    var call = GLOBAL_CUSTOM_SYSCALL_MAP[syscall];
+    if (call) {
+        var toSend = { "data": msg, "type": syscall,"uuid":generateUUID() };
+
+        send_str = JSON.stringify(toSend);
+
+        //Get the sha-256 encoded string.
+        sha256_encoded_msg = await standardSha256(send_str);
+
+        //make hmac 
+        hmac_code = await computeHmac(sha256_encoded_msg, SECRET_KEY);
+        toSend['sign'] = hmac_code
+
+
+        GLOBAL_SOCKET.send(JSON.stringify(toSend));
+    }
+    else {
+        console.log("Error:The callback " + syscall + " is not registered.");
+    }
+}
+
+
+class Msghandler {
+    constructor(socket) {
+
+        this.socket = socket;
+        this.callBackWrappers = new Object({});
+        this.processed_map = new Object({});
+
+    }
+
+
+    async evaluateMsg(jsonMessage) {
+
+        var type = jsonMessage.type;
+        var uuid = jsonMessage.uuid;
+
+        
+
+        if (!(uuid in this.processed_map) && await verifyIncomingMessage(jsonMessage)) {
+            if (type == "EXECUTE_ONLY") {
+
+                //add it to processed list to maintain at most one call
+                this.processed_map[uuid] = true;
+
+                var content = jsonMessage.data;
+                this.handleExecuteJs(content);
+
+            }
+
+            else if (type == "REGISTER_CALLBACK") {
+
+                var id = jsonMessage.id;
+                var typeCallback = jsonMessage.callback_type;
+                var wrapper = this.registerCallback(id, typeCallback, uuid);
+
+                var container = { wrap: wrapper, type: typeCallback, Eleid: id };
+                console.log(container);
+
+            
+            }
+            else if (type == "UNREGISTER_CALLBACK") {
+                var uuid_callback = jsonMessage.id;
+                cont = this.callBackWrappers[uuid_callback];
+                id = cont.Eleid;
+                type = cont.type;
+                wrap = cont.wrap;
+                document.getElementById(id).removeEventListener(type, wrap);
+
+                delete this.callBackWrappers[uuid_callback];
+            }
+            else if (type == "GRAB_CONTENT") {
+                var id = jsonMessage.id;
+                var attrib = jsonMessage.attrib;
+
+                if (attrib == 'value') {
+                    var value = document.getElementById(id).value;
+                }
+                else if (attrib == 'text') {
+                    var value = document.getElementById(id).textContent;
+                }
+
+                else {
+                    var value = document.getElementById(id).getAttribute(attrib);
+                }
+
+                _HandleGrbContent(uuid, this.socket, value);
+            }
+
+
+            else if (type == "BATCH_UPDATE") {
+
+                //To update multiple things at once...
+
+                for (let index = 0; index < jsonMessage.batch.length; index++) {
+                    this.evaluateMsg(jsonMessage.batch[index]);
+
+                }
+            }
+
+
+            else {
+
+                //Check if some custom syscall is present if present call it
+
+                var callback = GLOBAL_CUSTOM_SYSCALL_MAP[type];
+                if (callback) {
+                    callback(jsonMessage);
+                }
+                else {
+                    console.log("[Error] No associated callback for custom syscall:" + type);
+                }
+            }
+
+        }
+        else {
+            console.log("Wrong uuid or signature did not match.Hence dropping the packet.");
+        }
+    }
+
+    async handleExecuteJs(js_content) {
+
+        var execution_type = js_content.js_type;
+        var args = js_content.args;
+
+        if (execution_type == 'updateText') {
+
+            //We need text:value and id:id
+            var text = args.text;
+            var id = args.id;
+
+            //Update the text
+            var ele = document.getElementById(id);
+
+            if (ele) {
+                ele.textContent = text;
+            }
+        }
+        else if (execution_type == 'update') {
+
+            //We need value:value, id:id and att:attribute
+            var id = args.id;
+            var value = args.value;
+            var att = args.att;
+
+            var ele = document.getElementById(id);
+
+            if (ele) {
+                ele.setAttribute(att, value);
+            }
+
+        }
+        else if (execution_type == 'updateStyle') {
+
+            //We need id:id , att:attribute and value:value
+            var id = args.id;
+            var value = args.value;
+            var att = args.att;
+
+
+
+            var js = "document.getElementById(\"" + id + "\").style." + att + " = \"" + value + "\" ;"
+            eval(js);
+        }
+        else if (execution_type == 'addstyleclass') {
+            HandleStyleClass(args);
+        }
+        else if (execution_type == 'remove') {
+
+            var id = args.id;
+            var att = args.att;
+            var ele = document.getElementById(id);
+            ele.removeAttribute(att);
+
+        }
+    }
+
+    async registerCallback(id, eventType, uuid) {
+
+        //To handle the REGISTER_CALLBACK syscalls...
+        var element = document.getElementById(id);
+        var wrapper = () => _HandleCallbackSend(uuid, this.socket);
+        if (element) {
+            element.addEventListener(eventType, wrapper);
+        }
+
+        return wrapper;
+
+
+    }
+
+}

pyui_desktop-0.5.0/PYUI/PYUICommonExecutable.spec

@@ -0,0 +1,64 @@
+# -*- mode: python ; coding: utf-8 -*-
+
+import os
+import glob
+
+# 1. Name of  well-defined folder
+FOLDER_BUILD = os.environ.get('FOLDER')
+FOLDET_OUT = os.environ.get('OUT')
+PROJECT_NAME = os.environ.get('NAME')
+IS_CONSOLE = os.environ.get('CONSOLE')
+if IS_CONSOLE == '0':
+    IS_CONSOLE = False
+else:
+    IS_CONSOLE = True
+
+MODULE_FOLDER = 'code'  # Change this to your folder's actual name
+
+dynamic_modules = []
+
+# 2. Automatically scan the folder for all Python files
+search_path = os.path.join(MODULE_FOLDER, "**", "*.py")
+for file_path in glob.glob(search_path, recursive=True):
+    if os.path.basename(file_path) != '__init__.py':
+        # Convert file path 'my_custom_folder/sub/module.py' -> 'my_custom_folder.sub.module'
+        module_name = os.path.splitext(file_path)[0].replace(os.sep, '.')
+        dynamic_modules.append(module_name)
+
+#
+
+a = Analysis(
+    ['bootstrap.py'],
+    pathex=[],
+    binaries=[],
+    datas=[('code', 'code'), ('compiled_layouts', 'compiled_layouts'), ('layouts', 'layouts')],
+    hiddenimports=dynamic_modules,
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False,
+    optimize=0,
+)
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.datas,
+    [],
+    name=PROJECT_NAME,
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=IS_CONSOLE,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)