only_ever_generator 0.9.5 → 0.9.7

package/dist/parse/parse_card/parse_cloze_card.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseClozeCard = void 0;
+class ParseClozeCard {
+    parse(data) {
+        try {
+            const content = data.card_content;
+            let correctOptions = content.correct_options;
+            let incorrectOptions = content.incorrect_options;
+            let allOptions = [...correctOptions, ...incorrectOptions];
+            let displayTitle = this._generateClozeCardDisplayTitle(data.card_content.prompt, allOptions);
+            let preparedData = this._prepareQuestionAndCorrectAnswers(content.prompt, correctOptions);
+            let finalQuestion = preparedData.prompt;
+            let parsedCorrectOptions = preparedData.options;
+            let parsedIncorrectoptions = incorrectOptions.map((e) => {
+                return {
+                    option: e,
+                    cloze: "null",
+                };
+            });
+            const finalParsedOptions = [
+                ...parsedCorrectOptions,
+                ...parsedIncorrectoptions,
+            ];
+            let clozeCardData = {
+                type: {
+                    category: "learning",
+                    sub_type: data.type,
+                },
+                heading: "",
+                displayTitle: displayTitle,
+                content: {
+                    question: finalQuestion,
+                    options: finalParsedOptions,
+                },
+                concepts: data.concepts,
+                facts: data.facts,
+                explanation: data.card_content.explanation,
+            };
+            return this._validateCloze(clozeCardData);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    _generateClozeCardDisplayTitle(question, answers) {
+        try {
+            let optionsString = "";
+            if (answers.length !== 0) {
+                optionsString = answers.join(", ");
+            }
+            return `${question} ---- ${optionsString}`;
+        }
+        catch (e) {
+            throw Error("Error in generating display title");
+        }
+    }
+    /// validate the cloze card
+    // 1. Has Empty cloze
+    // 2. has Duplicate Clozes
+    // 3. doesnt have any valid option,
+    // 4. Question length 320
+    // 5. More than 6 options
+    // 6. Less than 2 options
+    // 7. Max character for individual cloze: 90
+    _prepareQuestionAndCorrectAnswers(rawPrompt, correctOptions) {
+        try {
+            var finalCorrectOptions = [];
+            const regex = /{{(.*?)}}/g;
+            const transformed = rawPrompt.replace(regex, (match, p1) => {
+                // p1 is the captured group inside {{ }} (e.g., "fruit", "green")
+                const idx = correctOptions.indexOf(p1);
+                if (idx !== -1) {
+                    let cloze = `c${idx}`;
+                    finalCorrectOptions.push({
+                        option: p1,
+                        cloze: cloze,
+                    });
+                    return `{{c${idx}:${p1}}}`;
+                }
+                return match; // If not found in correct_options, leave as is or handle accordingly
+            });
+            return {
+                prompt: transformed,
+                options: finalCorrectOptions,
+            };
+        }
+        catch (e) {
+            throw Error("Error in preparing question and correct answers");
+        }
+    }
+    _validateCloze(clozeCard) {
+        var _a;
+        let clozeRegex = /\{\{c(\d+):([^}]+)\}\}/g;
+        try {
+            /// validate emptu cloze
+            let options = (_a = clozeCard.content.options) !== null && _a !== void 0 ? _a : [];
+            let question = clozeCard.content.question;
+            if (options.length < 2 || options.length > 6) {
+                throw Error("Number of cloze options are invalid");
+            }
+            /// There are no correct clozes// or null cloze or empty cloze
+            let correctOptions = options.find((e) => e.cloze != "null" && e.cloze != null && e.cloze.trim() != "");
+            if (correctOptions) {
+            }
+            else {
+                throw Error(" No valid clozes exists");
+            }
+            let rightClozes = options.filter((e) => e.cloze.startsWith("c"));
+            /// matches our cloze syntax
+            let clozeMatches = [...question.matchAll(clozeRegex)];
+            if (clozeMatches.length == 0) {
+                throw Error("Question Invalid");
+            }
+            else if (clozeMatches.length != rightClozes.length) {
+                throw Error(" Clozes in question doesnt match to clozes in options");
+            }
+            return clozeCard;
+        }
+        catch (e) {
+            throw Error(`Error in validating cloze card ${e.message}`);
+        }
+    }
+}
+exports.ParseClozeCard = ParseClozeCard;

package/dist/parse/parse_card/parse_flash_cards.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseFlashCard = void 0;
+class ParseFlashCard {
+    parse(data) {
+        try {
+            let displayTitle = this.generateFlashCardDisplayTitle(data.card_content.front, data.card_content.back);
+            let flashCardData = {
+                type: {
+                    category: "learning",
+                    sub_type: data.type,
+                },
+                heading: "",
+                displayTitle: displayTitle,
+                content: {
+                    front_content: data.card_content.front,
+                    back_content: data.card_content.back,
+                },
+                concepts: data.concepts,
+                explanation: data.card_content.explanation,
+                facts: data.facts,
+            };
+            return flashCardData;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    generateFlashCardDisplayTitle(front, back) {
+        return `${front} ---- ${back}`;
+    }
+}
+exports.ParseFlashCard = ParseFlashCard;

package/dist/parse/parse_card/parse_match_card.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseMatchCard = void 0;
+class ParseMatchCard {
+    constructor() {
+        this._parseMatchContent = (input) => {
+            const grouped = input.reduce((acc, { left_item, right_item }) => {
+                if (!acc[left_item]) {
+                    acc[left_item] = { left_item, right_item: [] };
+                }
+                acc[left_item].right_item.push(right_item);
+                return acc;
+            }, {});
+            return Object.values(grouped);
+        };
+    }
+    parse(cardData) {
+        try {
+            let content = cardData.card_content;
+            const finalContent = this._parseMatchContent(content);
+            let displayTitle = this._generateMatchCardDisplayTitle(content);
+            let matchCard = {
+                type: {
+                    category: "learning",
+                    sub_type: cardData.type,
+                },
+                heading: "",
+                content: finalContent,
+                //  content: cardData.card_content,
+                displayTitle: displayTitle,
+                concepts: cardData.concepts,
+                facts: cardData.facts,
+                explanation: cardData.card_content.explanation,
+            };
+            return this._validateMatch(matchCard);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    _generateMatchCardDisplayTitle(answers) {
+        let titles = [];
+        let counter = 65;
+        for (let data of answers) {
+            let value = data.right_item;
+            let leftData = data.left_item;
+            let letter = String.fromCharCode(counter);
+            titles.push(`${letter}. ${leftData} -- ${value}`);
+            counter++;
+        }
+        let displayTitle = titles.join(",");
+        return displayTitle;
+    }
+    _validateMatch(matchCard) {
+        let matches = matchCard.content;
+        let content = [];
+        try {
+            if (matches.length < 1 || matches.length > 8) {
+                throw Error("Invalid number of matches");
+            }
+            for (let elem of matches) {
+                if (elem.left_item.length <= 30 && elem.left_item.length != 0) {
+                    if (elem.right_item.length <= 40 && elem.right_item.length != 0) {
+                        content.push(elem);
+                    }
+                }
+            }
+            if (content.length >= 2) {
+                matchCard.content = content;
+            }
+            else {
+                throw Error("Invalid content");
+            }
+            return matchCard;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}
+exports.ParseMatchCard = ParseMatchCard;

package/dist/parse/parse_card/parse_mcq_card.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseMcqCard = void 0;
+class ParseMcqCard {
+    parse(data) {
+        try {
+            let mcqAnswers = [];
+            if (data.card_content.choices !== undefined &&
+                data.card_content.choices.length != 0) {
+                for (let choice of data.card_content.choices) {
+                    let answer = {
+                        answer: choice.choice,
+                        is_correct: choice.is_correct,
+                    };
+                    mcqAnswers.push(answer);
+                }
+            }
+            let displayTitle = this._generateMcqCardDisplayTitle(data.card_content.prompt, mcqAnswers);
+            let mcqCard = {
+                type: {
+                    category: "learning",
+                    sub_type: data.type,
+                },
+                heading: "",
+                displayTitle: displayTitle,
+                content: {
+                    question: data.card_content.prompt,
+                    answers: mcqAnswers,
+                },
+                concepts: data.concepts,
+                facts: data.facts,
+                explanation: data.card_content.explanation,
+            };
+            //   return mcqCard;
+            const isValid = this._validate(mcqCard);
+            if (isValid == true) {
+                return mcqCard;
+            }
+            else {
+                return null;
+            }
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    _generateMcqCardDisplayTitle(question, answers) {
+        let answersString = [];
+        if (answers.length != 0) {
+            for (let option of answers) {
+                let currentIndex = answers.indexOf(option) + 1;
+                let temp = `${currentIndex} . ${option.answer} `;
+                answersString.push(temp);
+            }
+            let resultString = answersString.join("");
+            let finalDisplayTitle = `${question} ---- ${resultString}`;
+            return finalDisplayTitle;
+        }
+        else {
+            return question;
+        }
+    }
+    /// validate mcq card
+    // 1. Check if atleast 1 correct answer exists
+    // 2. Length of answer shouldnt exceed  24 chars
+    // 3. Length of question shouldnt exceed 90 chars
+    // 4. If Any option is Empty
+    _validate(mcqCard) {
+        var _a;
+        try {
+            let isQuestionValid = mcqCard.content.question.length <= 90;
+            if (!isQuestionValid) {
+                throw new Error("Question length exceeded");
+            }
+            /// check if all are wrong answers
+            let exists = this._checkIfAllAnswersAreWrong(mcqCard.content.answers);
+            if (exists) {
+            }
+            else {
+                throw new Error("Every answers are wrong");
+            }
+            /// check if answers are of length <40 or is 0
+            let answerWhoseLengthisGreaterThan40or0 = ((_a = mcqCard.content.answers) !== null && _a !== void 0 ? _a : []).find((e) => e.answer.length == 0 || e.answer.length > 40);
+            if (answerWhoseLengthisGreaterThan40or0) {
+                throw new Error("Option has length more than 40 or is Empty");
+            }
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    _checkIfAllAnswersAreWrong(answers) {
+        let rightAnswer = answers.find((e) => e.is_correct == true);
+        if (rightAnswer) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+}
+exports.ParseMcqCard = ParseMcqCard;

package/dist/parse/parse_card_response.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseCardResponse = void 0;
+const parse_cloze_card_1 = require("./parse_card/parse_cloze_card");
+const parse_flash_cards_1 = require("./parse_card/parse_flash_cards");
+const parse_match_card_1 = require("./parse_card/parse_match_card");
+const parse_mcq_card_1 = require("./parse_card/parse_mcq_card");
+class ParseCardResponse {
+    parse(generatedData, isGapFill, sourceTaxonomy) {
+        let usage_data = generatedData.metadata;
+        try {
+            const cardData = [];
+            const unparsedTestCards = generatedData.generated_content.test_cards;
+            const type = generatedData.type;
+            if (unparsedTestCards !== undefined && unparsedTestCards.length != 0) {
+                for (let elem of unparsedTestCards) {
+                    const managedCardConcepts = this._mapIdToConcepts(elem.concepts_facts, sourceTaxonomy.concepts_facts);
+                    elem.concepts = managedCardConcepts;
+                    if (elem.type == "flash") {
+                        const flashCard = new parse_flash_cards_1.ParseFlashCard().parse(elem);
+                        if (flashCard != null && flashCard) {
+                            flashCard.heading = this._getCardReference(flashCard, sourceTaxonomy);
+                            cardData.push(flashCard);
+                        }
+                    }
+                    else if (elem.type == "mcq") {
+                        const mcqCard = new parse_mcq_card_1.ParseMcqCard().parse(elem);
+                        if (mcqCard != null && mcqCard) {
+                            mcqCard.heading = this._getCardReference(mcqCard, sourceTaxonomy);
+                            cardData.push(mcqCard);
+                        }
+                    }
+                    else if (elem.type == "cloze") {
+                        const clozeCard = new parse_cloze_card_1.ParseClozeCard().parse(elem);
+                        if (clozeCard && clozeCard != null) {
+                            clozeCard.heading = this._getCardReference(clozeCard, sourceTaxonomy);
+                            cardData.push(clozeCard);
+                        }
+                    }
+                    else if (elem.type == "match") {
+                        const matchCard = new parse_match_card_1.ParseMatchCard().parse(elem);
+                        if (matchCard && matchCard != null) {
+                            matchCard.heading = this._getCardReference(matchCard, sourceTaxonomy);
+                            cardData.push(matchCard);
+                        }
+                    }
+                }
+            }
+            else {
+                if (!isGapFill) {
+                    usage_data.status = "failed";
+                }
+            }
+            if (cardData.length == 0) {
+                usage_data.status = "failed";
+            }
+            return {
+                status_code: cardData.length == 0 ? 400 : 200,
+                metadata: usage_data,
+                type: type,
+                cards_data: cardData,
+            };
+        }
+        catch (e) {
+            return {
+                status_code: 500,
+                metadata: usage_data,
+                type: generatedData.type,
+            };
+        }
+    }
+    _getCardReference(generatedCardData, sourceTaxonomy) {
+        var _a, _b;
+        const cardConcepts = ((_a = generatedCardData.concepts) !== null && _a !== void 0 ? _a : []).map((e) => e.text);
+        const sourceConceptsFacts = (_b = sourceTaxonomy.concepts_facts) !== null && _b !== void 0 ? _b : [];
+        const firstMatchedConcept = sourceConceptsFacts.find((elem) => cardConcepts.includes(elem.text));
+        if (firstMatchedConcept) {
+            return firstMatchedConcept.reference;
+        }
+        else {
+            return "";
+        }
+    }
+    _mapIdToConcepts(cardConcepts, sourceConceptsFacts) {
+        // const cardData = cardC
+        const managedCardConcepts = [];
+        for (const cardConcept of cardConcepts) {
+            const matchedConcept = sourceConceptsFacts.find((e) => e.text.toLowerCase().trim() == cardConcept.text.toLowerCase().trim());
+            if (matchedConcept) {
+                managedCardConcepts.push({
+                    id: matchedConcept.id,
+                    text: matchedConcept.text,
+                });
+            }
+        }
+        return managedCardConcepts;
+    }
+}
+exports.ParseCardResponse = ParseCardResponse;

package/dist/parse/parse_source_content.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseSourceContent = void 0;
+class ParseSourceContent {
+    constructor(sourceContent) {
+        /// Format of Content
+        // content: {
+        //     title: source.title,
+        //     headings: source.headings,
+        //     content: source.content,
+        //     fields: fields,
+        //     taxonomy: source.source_taxonomy,
+        //     type: source.source_type
+        //   },
+        this.titles_to_remove = [
+            "See also",
+            "References",
+            "Further reading",
+            "External links",
+            "Notes and references",
+            "Bibliography",
+            "Notes",
+            "Cited sources",
+        ];
+        this.block_types_toremove = ["table", "empty_line"];
+        this.content = sourceContent;
+    }
+    parseData() {
+        let sourceType = this.content.type;
+        let afterSanitized;
+        if (sourceType == "video") {
+            afterSanitized = this.parseVideoContent(this.content.content);
+        }
+        else {
+            let dataAfterRemovingUnWantedBlocks = this.removeSectionsByTitle(this.content.content);
+            afterSanitized = this.sanitizeBlocks(dataAfterRemovingUnWantedBlocks);
+        }
+        return {
+            type: this.content.type,
+            title: this.content.title,
+            content: afterSanitized,
+            headings: this.content.headings,
+            taxonomy: this.content.taxonomy,
+        };
+    }
+    removeSectionsByTitle(data) {
+        let dataAfterRemoving = [];
+        for (let elem of data) {
+            if (elem.block_type == "heading" &&
+                this.titles_to_remove.includes(elem.content)) {
+                continue;
+            }
+            /// remove unwanted blcok types , for now `table` and `empty_line`
+            if (this.block_types_toremove.includes(elem.block_type)) {
+                continue;
+            }
+            if (elem.children) {
+                elem.children = this.removeSectionsByTitle(elem.children);
+            }
+            dataAfterRemoving.push(elem);
+        }
+        return dataAfterRemoving;
+    }
+    sanitizeTextContent(content) {
+        // Remove newline characters
+        content = content.replace(/\\n/g, " ");
+        // Remove internal link references, keeping only the link text
+        // Pattern explanation: [[link|text|index|wiki]] --> text
+        content = content.replace(/\[\[.*?\|(.*?)\|.*?\|wiki\]\]/g, "$1");
+        // Remove external links, keeping only the link text
+        // Pattern explanation: [url text] --> text
+        content = content.replace(/\[http[s]?:\/\/[^\s]+ ([^\]]+)\]/g, "$1");
+        // Remove Markdown link references, keeping only the link text
+        // Pattern explanation: ![link text](url) --> link text
+        content = content.replace(/\!\[([^\]]+)\]\([^\)]+\)/g, "$1");
+        return content;
+    }
+    sanitizeBlocks(blocks) {
+        let sanitizedBlocks = [];
+        blocks = blocks.filter((item) => item.block_type != "table");
+        blocks.forEach((block) => {
+            let sanitizedBlock = {};
+            for (let key in block) {
+                let value = block[key];
+                if (typeof value === "string") {
+                    sanitizedBlock[key] = this.sanitizeTextContent(value);
+                }
+                else if (Array.isArray(value)) {
+                    sanitizedBlock[key] = this.sanitizeBlocks(value);
+                }
+                else {
+                    sanitizedBlock[key] = value;
+                }
+            }
+            sanitizedBlocks.push(sanitizedBlock);
+        });
+        return sanitizedBlocks;
+    }
+    parseVideoContent(data) {
+        let finalChapters = [];
+        // let cleanedData = this.cleanTranscript(timeCodes);
+        data.forEach((e) => {
+            let combinedContent = this.cleanTranscript(e);
+            finalChapters.push({
+                startTime: e.startTime,
+                endTime: e.endTime,
+                content: combinedContent,
+                title: e.content,
+            });
+        });
+        return finalChapters;
+    }
+    // remove content inside [] which denotes non-speech sounds
+    isNonSpeech(content) {
+        // Check if the content is non-speech (enclosed in square brackets).
+        return /^\[.*\]$/.test(content.trim());
+    }
+    // remove non-essential content
+    cleanTranscript(data) {
+        var _a;
+        let finalContent = "";
+        let children = (_a = data.children) !== null && _a !== void 0 ? _a : [];
+        children.forEach((e) => {
+            let content = (e.content || "").trim();
+            if (this.isNonSpeech(content))
+                return;
+            content = content.replace(/\s+/g, " ");
+            finalContent += content;
+        });
+        return finalContent;
+    }
+    // collapse the timecode to 30 seconds
+    collapseTimeCodes(data, maxDuration = 30.0) {
+        // Collapse time codes into buckets of approximately maxDuration seconds.
+        const collapsedData = [];
+        let bucketStartTime = null;
+        let bucketEndTime = null;
+        let bucketContent = [];
+        let bucketDuration = 0.0;
+        data.forEach((entry) => {
+            const startTime = entry.start_time;
+            const endTime = entry.end_time;
+            const content = entry.content;
+            const entryDuration = endTime - startTime;
+            if (bucketStartTime === null) {
+                // Start a new bucket
+                bucketStartTime = startTime;
+                bucketEndTime = endTime;
+                bucketContent.push(content);
+                bucketDuration = entryDuration;
+            }
+            else if (bucketDuration + entryDuration <= maxDuration) {
+                // Add to current bucket
+                bucketEndTime = endTime;
+                bucketContent.push(content);
+                bucketDuration += entryDuration;
+            }
+            else {
+                // Close current bucket and start a new one
+                const collapsedEntry = {
+                    start_time: bucketStartTime,
+                    end_time: bucketEndTime,
+                    content: bucketContent.join(" "),
+                };
+                collapsedData.push(collapsedEntry);
+                // Start new bucket with current entry
+                bucketStartTime = startTime;
+                bucketEndTime = endTime;
+                bucketContent = [content];
+                bucketDuration = entryDuration;
+            }
+        });
+        // Add the last bucket if it exists
+        if (bucketContent.length > 0) {
+            const collapsedEntry = {
+                start_time: bucketStartTime,
+                end_time: bucketEndTime,
+                content: bucketContent.join(" "),
+            };
+            collapsedData.push(collapsedEntry);
+        }
+        return collapsedData;
+    }
+}
+exports.ParseSourceContent = ParseSourceContent;