only_ever_generator 0.4.9 → 0.5.0

package/dist/index.js

@@ -38,32 +38,32 @@ Object.defineProperty(exports, "OnlyEverGenerator", { enumerable: true, get: fun
 //   let headings = returnHeadings();
 //   cardResp.metadata = {
 //     "req_time": cardResp.generated_at ?? new Date(),
-//     "req_type": cardResp.type,
+//     "req_type": "card",
 //     "req_tokens": cardResp.usage_data?.prompt_tokens,
 //     "res_tokens": cardResp.usage_data?.completion_tokens,
 //     "model": '40-mini'
 // };
-//   let parsedData = new GenerateCards(new OpenAiService("","")).parse(cardResp,false,headings);
+//   let parsedData = new ParseCardResponse().parse(cardResp,false);
 //   res.send(parsedData)
 // });
-// // app.get("/typology", async (req, res) => {
-// //   {
-// //     let typologyPrompt = returnTypologyPrompt();
-// //     let cardPrompt = returnCardGenPrompt();
-// //     let args = new GenerateArgs(
-// //       true,
-// //       true,
-// //       false,
-// //        {
-// //         typology_prompt: typologyPrompt,
-// //         card_gen_prompt: cardPrompt,
-// //         summary_prompt: "",
-// //       }
-// //     )
-// //     let typologyRequest = await oeGen.generate(false, true);
-// //     res.send(typologyRequest);
-// //   }
-// // });
+// app.get("/typology", async (req, res) => {
+//   {
+//     let typologyPrompt = returnTypologyPrompt();
+//     let cardPrompt = returnCardGenPrompt();
+//     let args = new GenerateArgs(
+//       true,
+//       true,
+//       false,
+//        {
+//         typology_prompt: typologyPrompt,
+//         card_gen_prompt: cardPrompt,
+//         summary_prompt: "",
+//       }
+//     )
+//     let typologyRequest = await oeGen.generate(false, true);
+//     res.send(typologyRequest);
+//   }
+// });
 // app.listen(port, () => {
 //   console.log(`Example app listening at http://localhost:${port}`);
 // });

package/dist/parse/parse_card/parse_cloze_card.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseClozeCard = void 0;
+class ParseClozeCard {
+    parse(data) {
+        try {
+            let displayTitle = this._generateClozeCardDisplayTitle(data.card_content.prompt, data.card_content.options);
+            let clozeCardData = {
+                type: {
+                    category: "learning",
+                    sub_type: data.type,
+                },
+                heading: data.card_reference,
+                displayTitle: displayTitle,
+                content: {
+                    question: data.card_content.prompt,
+                    options: data.card_content.options,
+                },
+                concepts: data.concepts,
+                facts: data.facts,
+                bloomLevel: data.bloom_level,
+            };
+            return this._validateCloze(clozeCardData);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    _generateClozeCardDisplayTitle(question, answers) {
+        let optionsString = "";
+        if (answers.length !== 0) {
+            optionsString = answers
+                .map((item) => {
+                if (item.option !== undefined) {
+                    return item.option;
+                }
+                else {
+                    return "";
+                }
+            })
+                .join(", ");
+        }
+        return `${question} ---- ${optionsString}`;
+    }
+    /// 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
+    _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) {
+            return false;
+        }
+    }
+}
+exports.ParseClozeCard = ParseClozeCard;

package/dist/parse/parse_card/parse_match_card.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseMatchCard = void 0;
+class ParseMatchCard {
+    parse(cardData) {
+        try {
+            let content = cardData.card_content;
+            let displayTitle = this._generateMatchCardDisplayTitle(content);
+            let matchCard = {
+                type: {
+                    category: "learning",
+                    sub_type: cardData.type,
+                },
+                heading: cardData.card_reference,
+                content: content,
+                //  content: cardData.card_content,
+                displayTitle: displayTitle,
+                concepts: cardData.concepts,
+                facts: cardData.facts,
+                bloomLevel: cardData.bloom_level,
+            };
+            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.join(",");
+            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;
+        try {
+            for (let elem of matches) {
+                if (elem.left_item.length > 24 || elem.left_item.length == 0) {
+                    throw Error("Invalid Length of left item ");
+                }
+                else if (elem.right_item[0].length > 24 || elem.right_item[0].length == 0) {
+                    throw Error(" Invalid Length of right item");
+                }
+            }
+            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: data.card_reference,
+                displayTitle: displayTitle,
+                content: {
+                    question: data.card_content.prompt,
+                    answers: mcqAnswers,
+                },
+                concepts: data.concepts,
+                facts: data.facts,
+                bloomLevel: data.bloom_level,
+            };
+            //   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

@@ -1,288 +1,98 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParseCardResponse = void 0;
-const cardResponse = {
-    "status_code": 200,
-    "usage_data": {
-        "prompt_tokens": 9781,
-        "completion_tokens": 1915,
-        "total_tokens": 11696
-    },
-    "generated_content": {
-        "missing_concepts": [
-            "Faraday's laws of electrolysis",
-            "Humphry Davy",
-            "Electrolytic cell",
-            "Decomposition potential",
-            "Oxidation",
-            "Reduction",
-            "Electrolysis of seawater",
-            "Electrometallurgy",
-            "Electroplating",
-            "Electrochemical machining",
-            "Electrochemistry",
-            "Electrocatalysis",
-            "Electrorefining",
-            "Electrolysis of carbon dioxide",
-            "Energy changes during electrolysis",
-            "Electrocrystallization",
-            "Electrolysis of Iron Ore"
-        ],
-        "missing_facts": [
-            "Michael Faraday introduced the term 'electrolysis' in 1834",
-            "The first demonstration of key electrolysis concepts was by William Nicholson and Anthony Carlisle in the early nineteenth century",
-            "Humphry Davy discovered several alkali and alkaline earth metals by electrolysis",
-            "Electrolysis played a key role in isolating and identifying new elements like lithium, chlorine, and fluorine",
-            "The Hall–Héroult process led to a significant drop in the price of aluminum",
-            "Hydrogen and oxygen are produced in a 2:1 ratio by the electrolysis of water",
-            "The electrolysis of seawater can result in the production of alkali hydroxides",
-            "Electrometallurgy is used in the production of various metals",
-            "Electroplating involves the deposition of a thin metal film onto a substrate material",
-            "Electrochemical machining is used for deburring or etching metal surfaces",
-            "Electrocatalysis involves the acceleration of electrochemical reactions",
-            "Electrorefining is used to obtain pure metals from impure ones",
-            "The electrolysis of carbon dioxide can produce methane, ethylene, or ethanol",
-            "Energy changes during electrolysis involve the addition of electrical energy, equal to the change in Gibbs free energy plus system losses",
-            "Electrocrystallization is a method for obtaining conductive crystals using electrolysis",
-            "Electrolysis of Iron Ore can eventually result in the reduction of emissions from steel production"
-        ],
-        "test_cards": [
-            {
-                "type": "flash",
-                "card_content": {
-                    "front": "Who introduced the term 'electrolysis' and in which year?",
-                    "back": "Michael Faraday introduced the term 'electrolysis' in 1834"
-                },
-                "card_reference": "Electrolysis#Etymology",
-                "concepts": [],
-                "facts": [
-                    "Michael Faraday introduced the term 'electrolysis' in 1834"
-                ]
-            },
-            {
-                "type": "flash",
-                "card_content": {
-                    "front": "What was the significance of the Hall–Héroult process?",
-                    "back": "The Hall–Héroult process led to a significant drop in the price of aluminum"
-                },
-                "card_reference": "Electrolysis#Industrial uses",
-                "concepts": [
-                    "Hall–Héroult process"
-                ],
-                "facts": [
-                    "The Hall–Héroult process led to a significant drop in the price of aluminum"
-                ]
-            },
-            {
-                "type": "mcq",
-                "card_content": {
-                    "prompt": "What does the electrolysis of water produce?",
-                    "choices": [
-                        {
-                            "choice": "Oxygen and carbon dioxide",
-                            "is_correct": false
-                        },
-                        {
-                            "choice": "Hydrogen and oxygen",
-                            "is_correct": true
-                        },
-                        {
-                            "choice": "Nitrogen and helium",
-                            "is_correct": false
+const logger_1 = require("../logger");
+const parse_cloze_card_1 = require("./parse_card/parse_cloze_card");
+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) {
+        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) {
+                    if (elem.type == "flash") {
+                        const flashCard = this.parseFlashCard(elem);
+                        if (flashCard != null && flashCard) {
+                            this.parseFlashCard(flashCard);
                         }
-                    ]
-                },
-                "card_reference": "Electrolysis#Process of electrolysis",
-                "concepts": [
-                    "Electrometallurgy"
-                ],
-                "facts": [
-                    "Hydrogen and oxygen are produced in a 2:1 ratio by the electrolysis of water"
-                ]
-            },
-            {
-                "type": "cloze",
-                "card_content": {
-                    "prompt": "Electrolysis is the passing of a direct electric current through an {{c0:electrolyte}} producing chemical reactions at the electrodes and decomposition of the materials.",
-                    "options": [
-                        {
-                            "option": "electrolyte",
-                            "cloze": "c0"
-                        },
-                        {
-                            "option": "anode",
-                            "cloze": "null"
-                        },
-                        {
-                            "option": "cathode",
-                            "cloze": "null"
+                    }
+                    else if (elem.type == "mcq") {
+                        const mcqCard = new parse_mcq_card_1.ParseMcqCard().parse(elem);
+                        if (mcqCard != null && mcqCard) {
+                            cardData.push(mcqCard);
                         }
-                    ]
-                },
-                "card_reference": "Electrolysis#Overview",
-                "concepts": [],
-                "facts": []
-            },
-            {
-                "type": "match",
-                "card_content": {
-                    "right_choice 1": "Electrometallurgy",
-                    "right_choice 2": "Electroplating",
-                    "right_choice 3": "Electrochemical machining",
-                    "right_choice 4": "Electrochemistry",
-                    "right_choice 5": "Electrocatalysis",
-                    "right_choice 6": "Electrorefining",
-                    "right_choice 7": "Electrolysis of carbon dioxide",
-                    "right_choice 8": "Energy changes during electrolysis",
-                    "Electrometallurgy": "The process of producing metals using electricity",
-                    "Electroplating": "Deposition of thin metal film onto a substrate material",
-                    "Electrochemical machining": "Deburring or etching metal surfaces",
-                    "Electrochemistry": "Study of the interchange of chemical and electrical energy",
-                    "Electrocatalysis": "Acceleration of electrochemical reactions",
-                    "Electrorefining": "Obtaining pure metals from impure ones"
-                },
-                "card_reference": "Electrolysis#Industrial uses",
-                "concepts": [
-                    "Electrometallurgy",
-                    "Electroplating",
-                    "Electrochemical machining",
-                    "Electrochemistry",
-                    "Electrocatalysis",
-                    "Electrorefining",
-                    "Electrolysis of carbon dioxide",
-                    "Energy changes during electrolysis"
-                ],
-                "facts": [
-                    "Electrometallurgy is used in the production of various metals",
-                    "Electroplating involves the deposition of a thin metal film onto a substrate material",
-                    "Electrochemical machining is used for deburring or etching metal surfaces",
-                    "Electrochemistry is the study of the interchange of chemical and electrical energy",
-                    "Electrocatalysis involves the acceleration of electrochemical reactions",
-                    "Electrorefining is used to obtain pure metals from impure ones",
-                    "The electrolysis of carbon dioxide can produce methane, ethylene, or ethanol",
-                    "Energy changes during electrolysis involve the addition of electrical energy, equal to the change in Gibbs free energy plus system losses"
-                ]
-            },
-            {
-                "type": "mcq",
-                "card_content": {
-                    "prompt": "What is a key application of electrolysis?",
-                    "choices": [
-                        {
-                            "choice": "Production of metal from ore",
-                            "is_correct": false
-                        },
-                        {
-                            "choice": "Pulsing current results",
-                            "is_correct": false
-                        },
-                        {
-                            "choice": "Generating electrical potential",
-                            "is_correct": false
-                        },
-                        {
-                            "choice": "Production of chlorine and sodium hydroxide",
-                            "is_correct": true
+                    }
+                    else if (elem.type == "cloze") {
+                        const clozeCard = new parse_cloze_card_1.ParseClozeCard().parse(elem);
+                        if (clozeCard && clozeCard != null) {
+                            cardData.push(clozeCard);
                         }
-                    ]
-                },
-                "card_reference": "Electrolysis#Industrial uses",
-                "concepts": [
-                    "Electrochemistry",
-                    "Electrocatalysis",
-                    "Electrorefining"
-                ],
-                "facts": [
-                    "Production of chlorine and sodium hydroxide, called the Chloralkali process"
-                ]
-            },
-            {
-                "type": "cloze",
-                "card_content": {
-                    "prompt": "Oxidation of ions or neutral molecules occurs at the {{c0:anode}}. Reduction of ions or neutral molecules occurs at the {{c1:cathode}}.",
-                    "options": [
-                        {
-                            "option": "anode",
-                            "cloze": "c0"
-                        },
-                        {
-                            "option": "cathode",
-                            "cloze": "c1"
-                        },
-                        {
-                            "option": "electrolyte",
-                            "cloze": "null"
+                    }
+                    else if (elem.type == "match") {
+                        const matchCard = new parse_match_card_1.ParseMatchCard().parse(elem);
+                        if (matchCard && matchCard != null) {
+                            cardData.push(matchCard);
                         }
-                    ]
-                },
-                "card_reference": "Electrolysis#Oxidation and reduction at the electrodes",
-                "concepts": [
-                    "Oxidation",
-                    "Reduction"
-                ],
-                "facts": []
-            },
-            {
-                "type": "match",
-                "card_content": {
-                    "right_choice 1": "Electrolysis",
-                    "right_choice 2": "Electrocrystallization",
-                    "right_choice 3": "Electrolysis of Iron Ore",
-                    "right_choice 4": "Electrolysis of seawater",
-                    "right_choice 5": "Electrometallurgy"
-                },
-                "card_reference": "Electrolysis#Research trends",
-                "concepts": [
-                    "Electrolysis",
-                    "Electrocrystallization",
-                    "Electrolysis of Iron Ore",
-                    "Electrolysis of seawater",
-                    "Electrometallurgy"
-                ],
-                "facts": []
+                    }
+                }
             }
-        ]
-    },
-    "generated_at": 1718625081,
-    "type": "card_gen"
-};
-class ParseCardResponse {
-    constructor(generatedData) {
-        this.generatedData = generatedData;
-    }
-    parse() {
-        const cardData = [];
-        const usage_data = this.generatedData.usage_data;
-        const created_at = this.generatedData.created_at;
-        const unparsedTestCards = this.generatedData.test_cards;
-        for (let elem of unparsedTestCards) {
-            if (elem.type == 'flash') {
-                cardData.push(this.parseFlashCard(elem));
-            }
-            else if (elem.type == 'mcq') {
-                cardData.push(this.parseFlashCard(elem));
-            }
-            else if (elem.type == 'cloze') {
-                cardData.push(this.parseClozeCard(elem));
-            }
-            else if (elem.type == 'match') {
-                cardData.push(this.parseMatchCard(elem));
+            else {
+                if (!isGapFill) {
+                    usage_data.status = "failed";
+                }
             }
+            return {
+                status_code: 200,
+                metadata: usage_data,
+                type: type,
+                missing_concepts: [],
+                missing_facts: [],
+                cards_data: cardData,
+            };
+        }
+        catch (e) {
+            new logger_1.ErrorLogger({
+                type: "card_parsing",
+                data: e.message,
+                response: generatedData,
+            }).log();
+            return {
+                status_code: 500,
+                metadata: usage_data,
+                type: generatedData.type,
+            };
         }
-        usage_data['created_at'] = created_at;
-        usage_data['type'] = 'card_gen';
-        return {
-            'usage_data': usage_data,
-            'cards_data': cardData
-        };
     }
     parseFlashCard(data) {
+        try {
+            let displayTitle = this.generateFlashCardDisplayTitle(data.card_content.front, data.card_content.back);
+            let flashCardData = {
+                type: {
+                    category: "learning",
+                    sub_type: data.type,
+                },
+                heading: data.card_reference,
+                displayTitle: displayTitle,
+                content: {
+                    front_content: data.card_content.front,
+                    back_content: data.card_content.back,
+                },
+                concepts: data.concepts,
+                facts: data.facts,
+                bloomLevel: data.bloom_level,
+            };
+            return flashCardData;
+        }
+        catch (e) {
+            return null;
+        }
     }
-    parseMcqCard(data) {
-    }
-    parseClozeCard(data) {
-    }
-    parseMatchCard(data) {
+    generateFlashCardDisplayTitle(front, back) {
+        return `${front} ---- ${back}`;
     }
 }
 exports.ParseCardResponse = ParseCardResponse;