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

psdi_data_conversion/static/javascript/convertc2x.js

@@ -0,0 +1,107 @@
+/*
+  convertato.js
+  Version 1.0, 10th January 2025
+
+  This is the JavaScript which makes the convertc2x.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("c2x");
+    $("#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", 'c2x');
+    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);
+}

psdi_data_conversion/static/javascript/data.js

@@ -0,0 +1,176 @@
+// data.js
+
+const response = await fetch("/static/data/data.json");
+const data = JSON.parse(await response.text());
+
+const collator = new Intl.Collator();
+
+// This compare function takes multiple pairs of strings so that it can be
+// used to sort with multiple levels.
+
+function compare(...pairs) {
+
+    for (const pair of pairs) {
+
+        const pairResult = collator.compare(pair[0], pair[1]);
+
+        if (pairResult !== 0) {
+            return pairResult;
+        }
+    }
+
+    return 0;
+}
+
+async function getFormatByExtensionAndNote(extension, note) {
+
+    const formats = data.formats.filter(format =>
+        (format.extension === extension) && (format.note === note)
+    );
+
+    return formats[0];
+}
+
+export async function getInputFormats() {
+
+    const inFormatIds = new Set(data.converts_to.map(record => record.in_id));
+
+    const inFormats = data.formats.filter(format => inFormatIds.has(format.id));
+
+    return inFormats.sort((a, b) => compare([a.extension, b.extension], [a.note, b.note]))
+}
+
+export async function getOutputFormats() {
+
+    const outFormatIds = new Set(data.converts_to.map(record => record.out_id));
+
+    const outFormats = data.formats.filter(format => outFormatIds.has(format.id));
+
+    return outFormats.sort((a, b) => compare([a.extension, b.extension], [a.note, b.note]))
+}
+
+export async function getOutputFormatsForInputFormat(inExtension, inNote) {
+
+    const inputFormat = (data.formats.filter(format => (format.extension === inExtension) && (format.note === inNote)))[0];
+
+    if (inputFormat === undefined) {
+        return [];
+    }
+
+    const outFormatIds = new Set(data.converts_to.filter(record => record.in_id === inputFormat.id).map(record => record.out_id));
+
+    const outFormats = data.formats.filter(format => outFormatIds.has(format.id));
+
+    return outFormats.sort((a, b) => compare([a.extension, b.extension], [a.note, b.note]))
+}
+
+export async function getInputFormatsForOutputFormat(outExtension, outNote) {
+
+    const outputFormat = (data.formats.filter(format => (format.extension === outExtension) && (format.note === outNote)))[0];
+
+    if (outputFormat === undefined) {
+        return [];
+    }
+
+    const inFormatIds = new Set(data.converts_to.filter(record => record.out_id === outputFormat.id).map(record => record.in_id));
+
+    const inFormats = data.formats.filter(format => inFormatIds.has(format.id));
+
+    return inFormats.sort((a, b) => compare([a.extension, b.extension], [a.note, b.note]))
+}
+
+export async function getConverters(inExtension, inNote, outExtension, outNote) {
+
+    const inputFormat = (data.formats.filter(format => (format.extension === inExtension) && (format.note === inNote)))[0];
+    const outputFormat = (data.formats.filter(format => (format.extension === outExtension) && (format.note === outNote)))[0];
+
+    if ((inputFormat === undefined) || (outputFormat === undefined))  {
+        return [];
+    }
+
+    const convertersById = new Map(data.converters.map(converter => [converter.id, converter]));
+
+    const conversions = data.converts_to.filter(record => (record.in_id === inputFormat.id) && record.out_id === outputFormat.id);
+
+    const convertersWithDegreeOfSuccess = conversions.map(conversion => ({
+        name: convertersById.get(conversion.converters_id).name
+    }));
+
+    return convertersWithDegreeOfSuccess.sort((a, b) => compare(a.name, b.name ));
+}
+
+export async function getConverterByName(name) {
+    return (data.converters.filter(converter => (converter.name === name)))[0];
+}
+
+export async function getAllFormats() {
+    return data.formats.sort((a, b) => compare([a.extension, b.extension], [a.note, b.note]));
+}
+
+export async function getInputFlags(extension, note) {
+
+    const format = (data.formats.filter(format => (format.extension === extension) && (format.note === note)))[0];
+
+    if (format !== undefined) {
+
+        const obFlagsIn = new Set(data.obformat_to_flags_in.filter(entry => entry.formats_id === format.id).map(entry => entry.obflags_in_id));
+
+        return data.obflags_in.filter(entry => obFlagsIn.has(entry.id)).sort((a, b) => compare([a.flag, b.flag]));
+    }
+}
+
+export async function getOutputFlags(extension, note) {
+
+    const format = (data.formats.filter(format => (format.extension === extension) && (format.note === note)))[0];
+
+    if (format !== undefined) {
+
+        const obFlagsOut = new Set(data.obformat_to_flags_out.filter(entry => entry.formats_id === format.id).map(entry => entry.obflags_out_id));
+
+        return data.obflags_out.filter(entry => obFlagsOut.has(entry.id)).sort((a, b) => compare([a.flag, b.flag]));
+    }
+}
+
+export async function getInputArgFlags(extension, note) {
+
+    const format = await getFormatByExtensionAndNote(extension, note);
+
+    if (format === undefined) {
+        throw `Can't find format for ${extension} and ${note}`;
+    }
+
+    const argFlagEntries = data.obformat_to_argflags_in
+        .filter(entry => entry.formats_id === format.id)
+        .map(entry => entry.obargflags_in_id);
+
+    const argFlags = data.obargflags_in
+        .filter(entry => argFlagEntries.indexOf(entry.id) !== -1);
+
+    return argFlags.sort((a, b) => compare([a.flag, b.flag]));
+}
+
+export async function getOutputArgFlags(extension, note) {
+
+    const format = await getFormatByExtensionAndNote(extension, note);
+
+    if (format === undefined) {
+        throw `Can't find format for ${extension} and ${note}`;
+    }
+
+    const argFlagEntries = data.obformat_to_argflags_out
+        .filter(entry => entry.formats_id === format.id)
+        .map(entry => entry.obargflags_out_id);
+
+    const argFlags = data.obargflags_out
+        .filter(entry => argFlagEntries.indexOf(entry.id) !== -1);
+
+    return argFlags.sort((a, b) => compare([a.flag, b.flag]));
+}
+
+export async function getLevelChemInfo(inExtension, inNote, outExtension, outNote) {
+
+    const inputFormat = (data.formats.filter(format => (format.extension === inExtension) && (format.note === inNote)))[0],
+          outputFormat = (data.formats.filter(format => (format.extension === outExtension) && (format.note === outNote)))[0];
+
+    return [inputFormat, outputFormat];
+}