only_ever_generator 0.5.2 → 0.5.4

package/src/parse/parse_card/parse_match_card.ts

@@ -1,9 +1,20 @@
 import { match } from "assert";
 
+type InputItem = {
+  left_item: string;
+  right_item: string;
+};
+
+type OutputItem = {
+  left_item: string;
+  right_item: string[];
+};
+
 export class ParseMatchCard {
   parse(cardData: any) {
     try {
       let content = cardData.card_content;
+      const finalContent =this._parseMatchContent(content);
 
       let displayTitle = this._generateMatchCardDisplayTitle(content);
       let matchCard = {
@@ -11,8 +22,8 @@ export class ParseMatchCard {
           category: "learning",
           sub_type: cardData.type,
         },
-        heading: cardData.card_reference,
-        content: content,
+        heading:"",
+        content: finalContent,
         //  content: cardData.card_content,
         displayTitle: displayTitle,
         concepts: cardData.concepts,
@@ -26,11 +37,13 @@ export class ParseMatchCard {
     }
   }
 
+  
+
   _generateMatchCardDisplayTitle(answers: any) {
     let titles: string[] = [];
     let counter = 65;
     for (let data of answers) {
-      let value = data.right_item.join(",");
+      let value = data.right_item;
       let leftData = data.left_item;
       let letter = String.fromCharCode(counter);
       titles.push(`${letter}. ${leftData} -- ${value}`);
@@ -40,16 +53,38 @@ 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;
+    }, {});
+  
+    return Object.values(grouped);
+  };
+
   _validateMatch(matchCard: any){
     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 > 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")
+            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){

package/src/parse/parse_card/parse_mcq_card.ts

@@ -24,7 +24,7 @@ export class ParseMcqCard {
           category: "learning",
           sub_type: data.type,
         },
-        heading: data.card_reference,
+        heading: "",
         displayTitle: displayTitle,
         content: {
           question: data.card_content.prompt,

package/src/parse/parse_card_response.ts

@@ -4,7 +4,7 @@ import { ParseMatchCard } from "./parse_card/parse_match_card";
 import { ParseMcqCard } from "./parse_card/parse_mcq_card";
 
 export class ParseCardResponse {
-  parse(generatedData: any, isGapFill: boolean) {
+  parse(generatedData: any, isGapFill: boolean, sourceTaxonomy: any) {
     let usage_data = generatedData.metadata;
     try {
       const cardData = [];
@@ -15,21 +15,25 @@ export class ParseCardResponse {
           if (elem.type == "flash") {
             const flashCard = this.parseFlashCard(elem);
             if (flashCard != null && flashCard) {
-              this.parseFlashCard(flashCard);
+              flashCard.heading = this._getCardReference(flashCard, sourceTaxonomy);
+              cardData.push(flashCard);
             }
           } else if (elem.type == "mcq") {
             const mcqCard = new ParseMcqCard().parse(elem);
             if (mcqCard != null && mcqCard) {
+              mcqCard.heading = this._getCardReference(mcqCard, sourceTaxonomy);
               cardData.push(mcqCard);
             }
           } else if (elem.type == "cloze") {
             const clozeCard = new ParseClozeCard().parse(elem);
             if (clozeCard && clozeCard != null) {
+              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);
               cardData.push(matchCard);
             }
           }
@@ -77,7 +81,7 @@ export class ParseCardResponse {
           category: "learning",
           sub_type: data.type,
         },
-        heading: data.card_reference,
+        heading : "",
         displayTitle: displayTitle,
         content: {
           front_content: data.card_content.front,
@@ -97,4 +101,36 @@ export class ParseCardResponse {
   generateFlashCardDisplayTitle(front: string, back: string) {
     return `${front} ---- ${back}`;
   }
+
+  _getCardReference(generatedCardData: any, sourceTaxonomy: any) {
+    const cardConcepts = generatedCardData.concepts ?? [];
+    const cardFacts = generatedCardData.facts ?? [];
+    const combinedCardFactsAndConcepts = [...cardConcepts, ...cardFacts];
+
+    const sourceConcepts = sourceTaxonomy.concepts ?? [];
+    const sourceFacts = sourceTaxonomy.facts ?? [];
+
+    const mappedSourceConcepts = sourceConcepts.map((elem: any) => {
+      return {
+        "text": elem.concept_text,
+        reference: elem.reference,
+      };
+    });
+    const mappedSourceFacts = sourceFacts.map((elem: any) => {
+      return {
+        "text": elem.fact_text,
+        reference: elem.reference,
+      };
+    });
+
+    const compinedConceptsAndFacts = [...mappedSourceConcepts, ...mappedSourceFacts];
+    const firstMatchedConcept =  compinedConceptsAndFacts.find((elem: any) => combinedCardFactsAndConcepts.includes(elem.text));
+
+
+    if(firstMatchedConcept){
+      return firstMatchedConcept.reference;
+    }else{
+      return "";
+    }
+  }
 }