only_ever_generator 0.4.8 → 0.5.0

package/src/index.ts

@@ -12,6 +12,7 @@ import { OnlyEverGenerator } from "./bootstrap/app";
 // import { returnPromptData } from "./constants/prompt_data";
 // import { GenerateCards } from "./card_gen/generate_cards";
 // import { OpenAiService } from "./services/open_ai_service";
+// import { ParseCardResponse } from "./parse/parse_card_response";
 
 /// While Publishing the package , and using this code as a separate npm module
 /// uncomment the below line and comment all the others, expect the import of OnlyEverGenerator
@@ -44,35 +45,36 @@ import { OnlyEverGenerator } from "./bootstrap/app";
 // app.get("/parseCardData", async(req,res)=>{
 //   let cardResp = returnCardResponse();
 //   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/src/parse/parse_card/parse_cloze_card.ts

@@ -0,0 +1,90 @@
+export class ParseClozeCard {
+  parse(data: any) {
+    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: string, answers: Array<any>) {
+    let optionsString = "";
+    if (answers.length !== 0) {
+      optionsString = answers
+        .map((item: { option: any }) => {
+          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: any) {
+    let clozeRegex = /\{\{c(\d+):([^}]+)\}\}/g;
+
+    try {
+      /// validate emptu cloze
+      let options = clozeCard.content.options ?? [];
+      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: any) => e.cloze != "null" && e.cloze != null && e.cloze.trim() != ""
+      );
+      if (correctOptions) {
+      } else {
+        throw Error(" No valid clozes exists");
+      }
+
+      let rightClozes = options.filter((e: any) => 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;
+    }
+  }
+}

package/src/parse/parse_card/parse_match_card.ts

@@ -0,0 +1,59 @@
+import { match } from "assert";
+
+export class ParseMatchCard {
+  parse(cardData: any) {
+    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: any) {
+    let titles: string[] = [];
+    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: any){
+    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;
+    }
+  }
+}

package/src/parse/parse_card/parse_mcq_card.ts

@@ -0,0 +1,105 @@
+export class ParseMcqCard {
+  parse(data: any) {
+    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: string, answers: any) {
+    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: any) {
+    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 = (
+        mcqCard.content.answers ?? []
+      ).find((e: any) => 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: any[]) {
+    let rightAnswer = answers.find((e) => e.is_correct == true);
+    if (rightAnswer) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+}