psdi-data-conversion 0.0.23__py3-none-any.whl

psdi_data_conversion/static/javascript/common.js

@@ -0,0 +1,42 @@
+/**
+ * @file common.js
+ * @date 2025-02-14
+ * @author Bryan Gillis
+ */
+
+
+/**
+ * Gets whether or not the app is operating in "Service mode"
+ * 
+ * This is the mode used for the public web app.
+ *
+ * @return {bool} True indicates service mode, False indicates local mode
+ */
+export function getServiceMode() {
+  return sessionStorage.getItem("service_mode");
+}
+
+/**
+ * Sets the service mode for the CSS document of the current page
+ */
+export function loadServiceMode() {
+  document.documentElement.setAttribute("service-mode", getServiceMode());
+}
+
+/**
+ * Gets whether or not the app is operating in "Production mode"
+ * 
+ * This is the mode used in staging/production deployments, but not dev deployments
+ *
+ * @return {bool} True indicates production mode, False indicates dev mode
+ */
+export function getProductionMode() {
+  return sessionStorage.getItem("production_mode");
+}
+
+/**
+ * Sets the production mode for the CSS document of the current page
+ */
+export function loadProductionMode() {
+  document.documentElement.setAttribute("production-mode", getProductionMode());
+}

psdi_data_conversion/static/javascript/convert.js

@@ -0,0 +1,296 @@
+/*
+  convert.js
+  Version 1.0, 24th January 2025
+
+  This is the JavaScript which makes the convert.htm gui work.
+*/
+
+
+import { getInputFlags, getOutputFlags, getInputArgFlags, getOutputArgFlags } from "./data.js";
+import { commonConvertReady, convertFile, getExtCheck, splitArchiveExt, isArchiveExt } from "./convert_common.js"
+
+var token = "",
+    max_file_size = 0,
+    in_ext = "",
+    out_ext = "",
+    in_str = "",
+    out_str = "";
+
+$(document).ready(function () {
+    [token, max_file_size, in_str, in_ext, out_str, out_ext] = commonConvertReady("Open Babel");
+
+    $('input[name="coordinates"]').change(coordOptionAvailability);
+    $("#uploadButton").click(submitFile);
+    $("#inFlags").click(blurBox);
+    $("#outFlags").click(blurBox);
+
+    getFlags("in", in_str);
+    getFlags("out", out_str);
+    getFlags("in_arg", in_str);
+    getFlags("out_arg", out_str);
+});
+
+// On clicking on an option flag, the select box loses focus so that the light font and dark background (Chrome) appears immediately.
+function blurBox(event) {
+    this.blur();
+}
+
+// On ticking a checkbox, a text box for entry of an option flag argument appears next to it. On unticking, the text box disappears.
+function enterArgument(event) {
+    var arg_id = this.id.replace('check', 'text'),
+        arg_label_id = this.id.replace('check', 'label');
+
+    if ($('#' + this.id).is(':checked')) {
+        // Show appropriate text box and its label
+        $('#' + arg_id).show();
+        $('#' + arg_label_id).show();
+    }
+    else {
+        // Hide appropriate text box (empty) and its label
+        $('#' + arg_id).val('').hide();
+        $('#' + arg_label_id).hide();
+    }
+}
+
+// Uploads a user-supplied file
+function submitFile() {
+    const file = $("#fileToUpload")[0].files[0],
+        [fname, ext] = splitArchiveExt(file.name);
+
+
+    var quality = sessionStorage.getItem("success"),
+        start = quality.indexOf(':') + 2,
+        finish = quality.lastIndexOf('(') - 1;
+
+    quality = quality.substring(start, finish);
+
+    const read_flags_text = $("#inFlags").find(":selected").text(),
+        read_flags = extractFlags(read_flags_text);
+
+    const write_flags_text = $("#outFlags").find(":selected").text(),
+        write_flags = extractFlags(write_flags_text);
+
+    var read_arg_flags = '',
+        write_arg_flags = '',
+        read_args = '',
+        write_args = '',
+        all_args_entered = true;
+
+    const checked_in = $('input[name=in_arg_check]:checked'),
+        checked_out = $('input[name=out_arg_check]:checked');
+
+    checked_in.each(function () {
+        read_arg_flags += $("#" + this.id).val()[0];
+        const arg = $("#in_arg_text" + this.id.substring(this.id.length - 1, this.id.length)).val();
+
+        if (/\S/.test(arg)) {
+            read_args += arg.trim() + '£';
+        }
+        else {
+            all_args_entered = false;
+        }
+    })
+
+    checked_out.each(function () {
+        write_arg_flags += $("#" + this.id).val()[0];
+        const arg = $("#out_arg_text" + this.id.substring(this.id.length - 1, this.id.length)).val();
+
+        if (/\S/.test(arg)) {
+            write_args += arg.trim() + '£';
+        }
+        else {
+            all_args_entered = false;
+        }
+    })
+
+    if (!all_args_entered) {
+        alert('All ticked option flags need additional information to be entered into the associated text box.');
+        return;
+    }
+
+    const coordinates = $('input[name="coordinates"]:checked').val(),
+        coordOption = $('input[name="coordOptions"]:checked').val();
+
+    // If the uploaded file was an archive, we'll expect to download one too. Otherwise we'll expect to download
+    // something with the output extension
+    const download_fname = isArchiveExt(ext) ? fname + "-" + out_ext + "." + ext : fname + "." + out_ext;
+
+    var form_data = new FormData();
+
+    form_data.append("token", token);
+    form_data.append("converter", 'Open Babel');
+    form_data.append("from", in_ext);
+    form_data.append("to", out_ext);
+    form_data.append("from_full", sessionStorage.getItem("in_str"));
+    form_data.append("to_full", sessionStorage.getItem("out_str"));
+    form_data.append("success", quality);
+    form_data.append("from_flags", read_flags);
+    form_data.append("to_flags", write_flags);
+    form_data.append("from_arg_flags", read_arg_flags);
+    form_data.append("from_args", read_args);
+    form_data.append("to_arg_flags", write_arg_flags);
+    form_data.append("to_args", write_args);
+    form_data.append("coordinates", coordinates);
+    form_data.append("coordOption", coordOption);
+    form_data.append("fileToUpload", file);
+    form_data.append("upload_file", true);
+    form_data.append("check_ext", getExtCheck());
+
+    convertFile(form_data, download_fname, fname);
+}
+
+// Retrieves option flags from selected text
+function extractFlags(flags_text) {
+    var flags = "",
+        regex = /: /g,
+        match = "";
+
+    while ((match = regex.exec(flags_text)) != null) {
+        flags += flags_text[match.index - 1];
+    }
+
+    return flags;
+}
+
+// Retrieves read or write option flags associated with a file format
+function getFlags(type, str) {
+
+    try {
+        const [ext, note] = str.split(": ");
+
+        if (type == "in") {
+            getInputFlags(ext, note).then((flags) => {
+                populateFlagBox(flags, type);
+            });
+        }
+        else if (type === "out") {
+            getOutputFlags(ext, note).then((flags) => {
+                populateFlagBox(flags, type);
+            });
+        }
+        else if (type == "in_arg") {
+
+            const in_arg_str_array = str.split(": "),
+                in_arg_ext = in_arg_str_array[0],          // e.g. "ins"
+                in_arg_note = in_arg_str_array[1];         // e.g. "ShelX"
+
+            getInputArgFlags(in_arg_ext, in_arg_note).then((argFlags) => {
+                addCheckboxes(argFlags, "in_arg");
+            });
+        }
+        else if (type == "out_arg") {
+
+            const out_arg_str_array = str.split(": "),
+                out_arg_ext = out_arg_str_array[0],          // e.g. "ins"
+                out_arg_note = out_arg_str_array[1];         // e.g. "ShelX"
+
+            getOutputArgFlags(out_arg_ext, out_arg_note).then((argFlags) => {
+                addCheckboxes(argFlags, "out_arg");
+            });
+        }
+
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+
+// Adds checkboxes for read or write option flags requiring an argument
+function addCheckboxes(argFlags, type) {
+
+    var container = $(`#${type}Flags`),
+        flagCount = 0;
+
+    if (argFlags.length > 0) {
+
+        $(`#${type}Label`).show();
+
+        for (const argFlag of argFlags) {
+
+            const flag = argFlag.flag;
+            const brief = argFlag.brief.replace(/^N\/A$/, "");
+            const description = argFlag.description.replace(/^N\/A$/, "");
+            const furtherInfo = argFlag.further_info.replace(/^N\/A$/, "");
+
+            container.append(`
+                <tr>
+                    <td><input type='checkbox' id="${type}_check${flagCount}" name=${type}_check value="${flag}"></input></td>
+                    <td><label for="${type}_check${flagCount}">${flag} [${brief}]: ${description}<label></td>
+                    <td><input type='text' id=${type}_text${flagCount} placeholder='-- type info. here --'></input></td>
+                    <td><span id= ${type}_label${flagCount}>${furtherInfo}</span></td>
+                </tr>`);
+
+            $(`#${type}_text${flagCount}`).hide();
+            $(`#${type}_label${flagCount}`).hide();
+            $(`#${type}_check${flagCount}`).change(enterArgument);
+
+            flagCount++;
+        }
+
+        container.append(`<br>`);
+    }
+    else {
+        $(`#${type}Label`).hide();
+
+        if (type == 'in_arg') {
+            $("#flag_break").hide();
+        }
+    }
+}
+
+// Populates a read or write option flag box
+function populateFlagBox(entries, type) {
+
+    const el = $("#" + type + "Flags");
+    const disp = $("#" + type + "FlagList");
+    const flagInfo = $("#" + type + "FlagInfo");
+
+    let infoLines = [];
+
+    if (entries.length != 0) {
+
+        disp.css({ display: "inline" });
+
+        for (const entry of entries) {
+
+            el.append(new Option(`${entry.flag}: ${entry.description}`));
+
+            const info = `${entry.flag}: ${entry.further_info}`;
+
+            if (!info.match(/.: N\/A/)) {
+                infoLines.push(info);
+            }
+        }
+
+    } else {
+
+        $("#" + type + "_label").hide();
+        $("#" + type + "_flag_break").hide();
+        el.hide();
+    }
+
+    el.append(new Option(""));
+
+    for (const infoLine of infoLines) {
+
+        const div = $("<div>");
+
+        div.text(infoLine);
+
+        flagInfo.append(div);
+    }
+}
+
+// Disable coordinate options if calculation type is 'neither,' otherwise enable
+function coordOptionAvailability(event) {
+    const calcType = $('input[name="coordinates"]:checked').val();
+
+    if (calcType == 'neither') {
+        $('input[name="coordOptions"]').prop({ disabled: true });
+    }
+    else {
+        $('input[name="coordOptions"]').prop({ disabled: false });
+    }
+}
+

psdi_data_conversion/static/javascript/convert_common.js

@@ -0,0 +1,252 @@
+/*
+  convert_common.js
+  Version 1.0, 17th December 2024
+*/
+
+const SECOND = 1000; // Milliseconds
+const CONVERT_TIMEOUT = 60 * SECOND;
+const MEGABYTE = 1024 * 1024;
+
+const ZIP_EXT = "zip"
+const TAR_EXT = "tar"
+const GZ_EXT = "gz"
+const BZ_EXT = "bz"
+const XZ_EXT = "gz"
+const TARGZ_EXT = "tar.gz"
+const TARBZ_EXT = "tar.bz"
+const TARXZ_EXT = "tar.xz"
+
+// Whether or not file extensions will be checked
+let extCheck = true;
+
+// Whether or not the user wants to also get the log file
+let requestLog = false;
+
+var token = "",
+    max_file_size = 0,
+    in_ext = "",
+    out_ext = "",
+    in_str = "",
+    out_str = "";
+
+export function commonConvertReady(converter) {
+    token = sessionStorage.getItem("token");
+    max_file_size = sessionStorage.getItem("max_file_size");
+
+    in_str = sessionStorage.getItem("in_str");
+    out_str = sessionStorage.getItem("out_str");
+
+    // $$$$$ FUNCTION FOR THIS? $$$$$
+    const in_str_array = in_str.split(": ");
+    in_ext = in_str_array[0];                // e.g. "ins"
+    const in_note = in_str_array[1];         // e.g. "ShelX"
+
+    const out_str_array = out_str.split(": ");
+    out_ext = out_str_array[0];
+    const out_note = out_str_array[1];
+
+    $("#heading").html("Convert from \'" + in_ext + "\' (" + in_note + ") to \'" + out_ext + "\' (" + out_note +
+        ") using " + converter);
+
+    $("#extCheck").click(setExtCheck);
+    $("#requestLog").click(setRequestLog);
+    $("#fileToUpload").change(checkFile);
+
+    return [token, max_file_size, in_str, in_ext, out_str, out_ext];
+}
+
+// Converts user-supplied file to another format and downloads the resulting file
+export function convertFile(form_data, download_fname, fname) {
+
+    let convertTimedOut = false;
+
+    var jqXHR = $.ajax({
+        url: `/convert/`,
+        type: "POST",
+        data: form_data,
+        processData: false,
+        contentType: false,
+        timeout: CONVERT_TIMEOUT,
+        success: async function () {
+            if (!convertTimedOut) {
+                await downloadFile(`../downloads/${download_fname}`, download_fname)
+
+                let msg = "To the best of our knowledge, this conversion has worked. A download prompt for your " +
+                    "converted file should now be open for you.";
+                if (requestLog) {
+                    msg += " A download prompt for the log will appear when you close this box.\n\n" +
+                        "You may need to tell your browser to allow this site to download multiple files and try the " +
+                        "conversion again if your browser initially disallows the download of the log file.";
+                }
+                alert(msg);
+
+                if (requestLog) {
+                    await downloadFile(`../downloads/${fname}.log.txt`, fname + '.log.txt')
+                }
+            }
+
+            var fdata = new FormData();
+
+            fdata.append("filename", download_fname);
+            fdata.append("logname", fname + '.log.txt');
+
+            $.ajax({
+                url: `/delete/`,
+                type: "POST",
+                data: fdata,
+                processData: false,
+                contentType: false
+            })
+                .fail(function (e) {
+                    // For debugging
+                    console.log("Error deleting remote files after download");
+                    console.log(e.status);
+                    console.log(e.responseText);
+                })
+        },
+        error: function (xmlhttprequest, textstatus, message) {
+            if (textstatus === "timeout") {
+                convertTimedOut = true;
+                alert("ERROR: Conversion attempt timed out. This may be because the conversion is too complicated, " +
+                    "or because the server is currently busy.");
+                console.log("ERROR: Conversion timed out")
+            }
+        }
+    })
+        .fail(function (e, textstatus, message) {
+            let errLog = `/static/downloads/${fname}.log.txt`;
+
+            fetch(errLog, { cache: "no-store" })
+                .then(function (response) {
+                    if (response.status == 404) {
+                        alert("An unknown error occurred, which produced no error log. If you are using the web " +
+                            "app, please provide feedback on the conversion that you were attempting by clicking on " +
+                            "'Contact' in the navigation bar.\n" +
+                            "If you were trying to run this locally, check your terminal for error messages which " +
+                            "may help explain what went wrong.");
+                        return "";
+                    }
+                    else if (!convertTimedOut) {
+                        return response.text();
+                    }
+                })
+                .then(function (text) {
+                    if (text != "" && text != null)
+                        alert("ERROR: Request to the backend converter returned status '" + textstatus +
+                            "' and message: " + message + "\n" + text);
+                })
+
+            // For debugging
+            console.log("Error converting file");
+            console.log(e.status);
+            console.log(e.responseText);
+        })
+}
+
+function setExtCheck(event) {
+    extCheck = this.checked;
+}
+
+export function getExtCheck() {
+    return extCheck;
+}
+
+function setRequestLog(event) {
+    requestLog = this.checked;
+}
+
+export function splitArchiveExt(filename) {
+    const filename_segments = filename.split(".");
+    // Check for extreme cases
+    if (filename_segments.length == 0) {
+        return ["", ""];
+    } else if (filename_segments.length == 1) {
+        return [filename, ""];
+    }
+
+    let base;
+    let ext = filename_segments.at(-1);
+
+    if ([GZ_EXT, BZ_EXT, XZ_EXT].includes(ext)) {
+        // In the case that the extension is one of the second parts of tarball extensions, check if the prior
+        // extension is "tar"
+        let prior_ext = filename_segments.at(-2);
+        if (prior_ext == TAR_EXT && filename_segments.length > 2) {
+            base = filename_segments.slice(0, -2).join(".");
+            ext = prior_ext + "." + ext;
+        } else {
+            base = filename_segments.slice(0, -1).join(".");
+        }
+    } else {
+        base = filename_segments.slice(0, -1).join(".");
+    }
+
+    return [base, ext];
+}
+
+export function isArchiveExt(ext) {
+    return [ZIP_EXT, TAR_EXT, TARGZ_EXT, TARBZ_EXT, TARXZ_EXT].includes(ext);
+}
+
+// Check that the file meets requirements for upload
+function checkFile(event) {
+
+    let allGood = true;
+    let file = this.files[0];
+    let message = "";
+
+    // Check file has the proper extension if checking is enabled
+    if (extCheck) {
+
+        const file_name = file.name;
+
+        const [_, ext] = splitArchiveExt(file_name);
+
+        if (![in_ext, ZIP_EXT, TAR_EXT, TARGZ_EXT, TARBZ_EXT, TARXZ_EXT].includes(ext)) {
+            message += "The file extension is not " + in_ext + " or a zip or tar archive extension" +
+                ": If you're confident this file is the correct type, untick the box above to disable file extension " +
+                "enforcement (note that zip/tar archives MUST have the correct extension, regardless of this " +
+                "tickbox). Otherwise, please select another file or change the 'from' format on the 'Home' page.";
+            allGood = false;
+        }
+    }
+
+    // Check file does not exceed maximum size
+    if (max_file_size > 0 && file.size > max_file_size) {
+        if (message !== "")
+            message += "\n\n";
+        message += "The file exceeds the maximum size limit of " + (max_file_size / MEGABYTE).toFixed(2) +
+            " MB; its size is " + (file.size / MEGABYTE).toFixed(2) + " MB.";
+        allGood = false;
+    }
+
+    if (allGood) {
+        $("#uploadButton").css({ "background-color": "var(--ifm-color-primary)", "color": "var(--ifm-hero-text-color)" });
+        $("#uploadButton").prop({ disabled: false });
+    } else {
+        $("#uploadButton").css({ "background-color": "var(--psdi-bg-color-secondary)", "color": "gray" });
+        $("#uploadButton").prop({ disabled: true });
+        alert(message);
+    }
+}
+
+/**
+ * Start a download of a file
+ * 
+ * The file is first fetched as a blob, then a link to download it is created, clicked, and removed
+ * 
+ * @param {str} path The path to the file to be downloaded
+ * @param {str} filename The desired filename of the downloaded file
+ * @returns {Promise<Response>}
+ */
+async function downloadFile(path, filename) {
+    return fetch(path)
+        .then(res => res.blob())
+        .then(data => {
+            var a = document.createElement("a");
+            a.href = window.URL.createObjectURL(data);
+            a.download = filename;
+            a.click();
+            a.remove();
+        });
+}

psdi_data_conversion/static/javascript/convertato.js

@@ -0,0 +1,107 @@
+/*
+  convertato.js
+  Version 1.0, 8th November 2024
+
+  This is the JavaScript which makes the convertato.htm gui work.
+*/
+
+import { commonConvertReady, convertFile, getExtCheck, splitArchiveExt, isArchiveExt } from "./convert_common.js"
+
+var token = "",
+    max_file_size = 0,
+    in_ext = "",
+    out_ext = "",
+    in_str = "",
+    out_str = "";
+
+$(document).ready(function () {
+    [token, max_file_size, in_str, in_ext, out_str, out_ext] = commonConvertReady("Atomsk");
+    $("#uploadButton").click(submitFile);
+});
+
+// Uploads a user-supplied file
+function submitFile() {
+    const file = $("#fileToUpload")[0].files[0],
+        [fname, ext] = splitArchiveExt(file.name);
+
+    var quality = sessionStorage.getItem("success"),
+        start = quality.indexOf(':') + 2,
+        finish = quality.lastIndexOf('(') - 1;
+
+    quality = quality.substring(start, finish);
+
+    const read_flags_text = $("#inFlags").find(":selected").text(),
+        read_flags = '';
+
+    const write_flags_text = $("#outFlags").find(":selected").text(),
+        write_flags = '';
+
+    var count = 0,
+        read_arg_flags = '',
+        write_arg_flags = '',
+        read_args = '',
+        write_args = '',
+        all_args_entered = true;
+
+    const checked_in = $('input[name=in_arg_check]:checked'),
+        checked_out = $('input[name=out_arg_check]:checked');
+
+    checked_in.each(function () {
+        read_arg_flags += $("#" + this.id).val()[0];
+        const arg = $("#in_arg_text" + this.id.substring(this.id.length - 1, this.id.length)).val();
+
+        if (/\S/.test(arg)) {
+            read_args += arg.trim() + '£';
+        }
+        else {
+            all_args_entered = false;
+        }
+    })
+
+    checked_out.each(function () {
+        write_arg_flags += $("#" + this.id).val()[0];
+        const arg = $("#out_arg_text" + this.id.substring(this.id.length - 1, this.id.length)).val();
+
+        if (/\S/.test(arg)) {
+            write_args += arg.trim() + '£';
+        }
+        else {
+            all_args_entered = false;
+        }
+    })
+
+    if (!all_args_entered) {
+        alert('All ticked option flags need additional information to be entered into the associated text box.');
+        return;
+    }
+
+    const coordinates = 'neither', //$('input[name="coordinates"]:checked').val(),
+        coordOption = 'medium'; //$('input[name="coordOptions"]:checked').val(),
+
+    // If the uploaded file was an archive, we'll expect to download one too. Otherwise we'll expect to download
+    // something with the output extension
+    const download_fname = isArchiveExt(ext) ? fname + "-" + out_ext + "." + ext : fname + "." + out_ext;
+
+    var form_data = new FormData();
+
+    form_data.append("token", token);
+    form_data.append("converter", 'Atomsk');
+    form_data.append("from", in_ext);
+    form_data.append("to", out_ext);
+    form_data.append("from_full", sessionStorage.getItem("in_str"));
+    form_data.append("to_full", sessionStorage.getItem("out_str"));
+    form_data.append("success", quality);
+    form_data.append("from_flags", read_flags);
+    form_data.append("to_flags", write_flags);
+    form_data.append("from_arg_flags", read_arg_flags);
+    form_data.append("from_args", read_args);
+    form_data.append("to_arg_flags", write_arg_flags);
+    form_data.append("to_args", write_args);
+    form_data.append("coordinates", coordinates);
+    form_data.append("coordOption", coordOption);
+    form_data.append("fileToUpload", file);
+    form_data.append("upload_file", true);
+    form_data.append("check_ext", getExtCheck());
+
+    convertFile(form_data, download_fname, fname);
+}