only_ever_generator 0.5.5 → 0.5.7

package/src/index.ts

@@ -17,10 +17,9 @@
 
 import { OnlyEverGenerator } from "./bootstrap/app";
 
-
 /// 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
-export {OnlyEverGenerator};
+export { OnlyEverGenerator };
 
 // . All the Codes Below uses express and are strictly for development purpose, while publishing the package, comment everything
 // below this line

package/src/logger.ts

@@ -1,31 +1,30 @@
-/// this method will call out atlas function and will write to a doc, incase of any errors: 
+/// this method will call out atlas function and will write to a doc, incase of any errors:
 /// this is only for developmemt use
 
 import axios from "axios";
 
+export class ErrorLogger {
+  data: any;
+  constructor(data: any) {
+    this.data = data;
+  }
 
-export class ErrorLogger{
-    data: any;
-    constructor(data: any){
-        this.data = data;
+  async log() {
+    try {
+      let response = await axios.post(
+        "https://us-east-1.aws.data.mongodb-api.com/app/oe-phase1-tkmsy/endpoint/oe_gen_logger",
+        {
+          data: this.data,
+        },
+        {
+          headers: {
+            "Content-Type": ["application/json"],
+          },
+        }
+      );
+      return response;
+    } catch (e) {
+      console.log(e);
     }
-
-    async log() {
-        try{
-       let response = await axios.post(
-            'https://us-east-1.aws.data.mongodb-api.com/app/oe-phase1-tkmsy/endpoint/oe_gen_logger',
-            {
-                data: this.data,
-            },
-            {
-                headers : {
-                    "Content-Type" : ['application/json']
-                }
-            }
-
-        );
-    return response;}catch(e){
-        console.log(e)
-    }
-    }
-}
+  }
+}

package/src/parse/parse_card/parse_cloze_card.ts

@@ -5,23 +5,32 @@ export class ParseClozeCard {
       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:any)=>{
-      return {
-        "option":e,
-        "cloze": "null"
-      };
-     });
-     const finalParsedOptions = [...parsedCorrectOptions,...parsedIncorrectoptions];
+      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: any) => {
+        return {
+          option: e,
+          cloze: "null",
+        };
+      });
+      const finalParsedOptions = [
+        ...parsedCorrectOptions,
+        ...parsedIncorrectoptions,
+      ];
       let clozeCardData = {
         type: {
           category: "learning",
           sub_type: data.type,
         },
-        heading:"",
+        heading: "",
         displayTitle: displayTitle,
         content: {
           question: finalQuestion,
@@ -39,14 +48,14 @@ export class ParseClozeCard {
   }
 
   _generateClozeCardDisplayTitle(question: string, answers: Array<any>) {
-    try{
-    let optionsString = "";
-    if (answers.length !== 0) {
-      optionsString = answers
-        .join(", ");
-    }
+    try {
+      let optionsString = "";
+      if (answers.length !== 0) {
+        optionsString = answers.join(", ");
+      }
 
-    return `${question} ---- ${optionsString}`;}catch(e){
+      return `${question} ---- ${optionsString}`;
+    } catch (e) {
       throw Error("Error in generating display title");
     }
   }
@@ -60,31 +69,34 @@ export class ParseClozeCard {
   // 6. Less than 2 options
   // 7. Max character for individual cloze: 90
 
-  _prepareQuestionAndCorrectAnswers(rawPrompt:String, correctOptions: Array<any>){
-    try{
-    var finalCorrectOptions = <any>[];
-    const regex = /{{(.*?)}}/g;
+  _prepareQuestionAndCorrectAnswers(
+    rawPrompt: String,
+    correctOptions: Array<any>
+  ) {
+    try {
+      var finalCorrectOptions = <any>[];
+      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){
+      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: any) {
@@ -118,7 +130,7 @@ export class ParseClozeCard {
       }
       return clozeCard;
     } catch (e: any) {
-     throw Error(`Error in validating cloze card ${e.message}`);
+      throw Error(`Error in validating cloze card ${e.message}`);
     }
   }
 }

package/src/parse/parse_card/parse_flash_cards.ts

@@ -0,0 +1,33 @@
+export class ParseFlashCard {
+  parse(data: any) {
+    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: string, back: string) {
+    return `${front} ---- ${back}`;
+  }
+}

package/src/parse/parse_card/parse_match_card.ts

@@ -14,7 +14,7 @@ export class ParseMatchCard {
   parse(cardData: any) {
     try {
       let content = cardData.card_content;
-      const finalContent =this._parseMatchContent(content);
+      const finalContent = this._parseMatchContent(content);
 
       let displayTitle = this._generateMatchCardDisplayTitle(content);
       let matchCard = {
@@ -22,7 +22,7 @@ export class ParseMatchCard {
           category: "learning",
           sub_type: cardData.type,
         },
-        heading:"",
+        heading: "",
         content: finalContent,
         //  content: cardData.card_content,
         displayTitle: displayTitle,
@@ -37,8 +37,6 @@ export class ParseMatchCard {
     }
   }
 
-  
-
   _generateMatchCardDisplayTitle(answers: any) {
     let titles: string[] = [];
     let counter = 65;
@@ -53,42 +51,44 @@ export class ParseMatchCard {
     return displayTitle;
   }
 
-   _parseMatchContent = (input: InputItem[]): OutputItem[] => {
-    const grouped = input.reduce<Record<string, OutputItem>>((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;
-    }, {});
-  
+  _parseMatchContent = (input: InputItem[]): OutputItem[] => {
+    const grouped = input.reduce<Record<string, OutputItem>>(
+      (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);
   };
 
-  _validateMatch(matchCard: any){
+  _validateMatch(matchCard: any) {
     let matches = matchCard.content;
     let content = [];
-    try{
-        if(matches.length < 1 || matches.length > 8){
-            throw Error("Invalid number of matches");
-        }
+    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);
-            }
+      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;
+      }
+      if (content.length >= 2) {
+        matchCard.content = content;
+      } else {
+        throw Error("Invalid content");
+      }
+      return matchCard;
+    } catch (e) {
+      return null;
     }
   }
 }

package/src/parse/parse_card_response.ts

@@ -1,5 +1,6 @@
 import { ErrorLogger } from "../logger";
 import { ParseClozeCard } from "./parse_card/parse_cloze_card";
+import { ParseFlashCard } from "./parse_card/parse_flash_cards";
 import { ParseMatchCard } from "./parse_card/parse_match_card";
 import { ParseMcqCard } from "./parse_card/parse_mcq_card";
 
@@ -13,9 +14,12 @@ export class ParseCardResponse {
       if (unparsedTestCards !== undefined && unparsedTestCards.length != 0) {
         for (let elem of unparsedTestCards) {
           if (elem.type == "flash") {
-            const flashCard = this.parseFlashCard(elem);
+            const flashCard = new ParseFlashCard().parse(elem);
             if (flashCard != null && flashCard) {
-              flashCard.heading = this._getCardReference(flashCard, sourceTaxonomy);
+              flashCard.heading = this._getCardReference(
+                flashCard,
+                sourceTaxonomy
+              );
               cardData.push(flashCard);
             }
           } else if (elem.type == "mcq") {
@@ -27,13 +31,19 @@ export class ParseCardResponse {
           } else if (elem.type == "cloze") {
             const clozeCard = new ParseClozeCard().parse(elem);
             if (clozeCard && clozeCard != null) {
-              clozeCard.heading = this._getCardReference(clozeCard, sourceTaxonomy);
+              clozeCard.heading = this._getCardReference(
+                clozeCard,
+                sourceTaxonomy
+              );
               cardData.push(clozeCard);
             }
           } else if (elem.type == "match") {
             const matchCard = new ParseMatchCard().parse(elem);
             if (matchCard && matchCard != null) {
-              matchCard.heading = this._getCardReference(matchCard, sourceTaxonomy);
+              matchCard.heading = this._getCardReference(
+                matchCard,
+                sourceTaxonomy
+              );
               cardData.push(matchCard);
             }
           }
@@ -43,13 +53,12 @@ export class ParseCardResponse {
           usage_data.status = "failed";
         }
       }
-      if(cardData.length == 0){
-        usage_data.status="failed";
-
+      if (cardData.length == 0) {
+        usage_data.status = "failed";
       }
 
       return {
-        status_code: cardData.length == 0 ? 400:200,
+        status_code: cardData.length == 0 ? 400 : 200,
         metadata: usage_data,
         type: type,
         missing_concepts: [],
@@ -70,38 +79,6 @@ export class ParseCardResponse {
     }
   }
 
-  parseFlashCard(data: any) {
-    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: string, back: string) {
-    return `${front} ---- ${back}`;
-  }
-
   _getCardReference(generatedCardData: any, sourceTaxonomy: any) {
     const cardConcepts = generatedCardData.concepts ?? [];
     const cardFacts = generatedCardData.facts ?? [];
@@ -112,24 +89,28 @@ export class ParseCardResponse {
 
     const mappedSourceConcepts = sourceConcepts.map((elem: any) => {
       return {
-        "text": elem.concept_text,
+        text: elem.concept_text,
         reference: elem.reference,
       };
     });
     const mappedSourceFacts = sourceFacts.map((elem: any) => {
       return {
-        "text": elem.fact_text,
+        text: elem.fact_text,
         reference: elem.reference,
       };
     });
 
-    const compinedConceptsAndFacts = [...mappedSourceConcepts, ...mappedSourceFacts];
-    const firstMatchedConcept =  compinedConceptsAndFacts.find((elem: any) => combinedCardFactsAndConcepts.includes(elem.text));
-
+    const compinedConceptsAndFacts = [
+      ...mappedSourceConcepts,
+      ...mappedSourceFacts,
+    ];
+    const firstMatchedConcept = compinedConceptsAndFacts.find((elem: any) =>
+      combinedCardFactsAndConcepts.includes(elem.text)
+    );
 
-    if(firstMatchedConcept){
+    if (firstMatchedConcept) {
       return firstMatchedConcept.reference;
-    }else{
+    } else {
       return "";
     }
   }