only_ever_generator 0.0.6 → 0.0.8

package/dist/parse/response_format_typology.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.returnTypologyData = void 0;
+const typologyResponse = {
+    "usage_data": {
+        "prompt_tokens": 11611,
+        "completion_tokens": 441,
+        "total_tokens": 12052
+    },
+    "generated_content": {
+        "field": [
+            "Sciences",
+            "Technology & Engineering",
+            "Education, Learning & Personal Development"
+        ],
+        "concepts": [
+            "Electrolysis",
+            "Faraday's Laws of Electrolysis",
+            "Electrolytic Cell",
+            "Decomposition Potential",
+            "Oxidation and Reduction at the Electrodes",
+            "Electrolysis of Water",
+            "Electrolysis of Carbon Dioxide",
+            "Electrocrystallization"
+        ],
+        "facts": [
+            "Electrolysis is the passing of a direct electric current through an electrolyte producing chemical reactions at the electrodes and decomposition of the materials.",
+            "In electrolysis, the quantity of the products is proportional to the current, and when two or more electrolytic cells are connected in series to the same power source, the products produced in the cells are proportional to their equivalent weight.",
+            "The main components required to achieve electrolysis are an electrolyte, electrodes, and an external power source.",
+            "Faraday's laws of electrolysis detail the amount of the products of electrolysis is related to the number of electrons in the reaction at the electrodes.",
+            "Decomposition potential or decomposition voltage refers to the minimum voltage between anode and cathode of an electrolytic cell that is needed for electrolysis to occur.",
+            "The electrochemical reduction of carbon dioxide can produce value-added chemicals such as methane, ethylene, and ethanol."
+        ],
+        "generate_cards": true,
+        "summary_cards": [
+            "Electrolysis is the process of passing direct electric current through an electrolyte, resulting in chemical reactions and the decomposition of materials.",
+            "Faraday's laws of electrolysis determine the relationship between the amounts of products generated and the electrons involved in the reaction at the electrodes.",
+            "Decomposition potential is the minimum voltage required between anode and cathode for electrolysis to occur.",
+            "The electrochemical reduction of carbon dioxide is a potential method for producing valuable chemicals such as methane, ethylene, and ethanol."
+        ]
+    },
+    "generated_at": "Tue, 20 Jan 1970 21:17:46 GMT"
+};
+function returnTypologyData() {
+    return typologyResponse;
+}
+exports.returnTypologyData = returnTypologyData;

package/dist/service/open_ai_request.js

@@ -43,7 +43,6 @@ function openAIRequest(content, prompt, token, model) {
             if (response.status == 200) {
                 console.log('success');
                 return (0, parse_openai_response_js_1.parseOpenAiSuccessResponse)(response.data);
-                // return JSON.parse(response.data.choices[0].message.content);
             }
             else {
                 console.log('failed');

package/dist/services/open_ai_service.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAiService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const parse_openai_response_1 = require("../utils/parse_openai_response");
+const api_constants_1 = require("../constants/api_constants");
+class OpenAiService {
+    constructor(apiKey, model) {
+        this.api_key = apiKey;
+        this.model = model;
+    }
+    sendRequest(prompt, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let message = [
+                    {
+                        "role": "system", "content": prompt
+                    }, {
+                        "role": "user", "content": content
+                    }
+                ];
+                const url = (0, api_constants_1.openAiEndPoint)();
+                let response = yield axios_1.default.post(url, {
+                    "model": this.model,
+                    "messages": message,
+                    "response_format": { "type": "json_object" },
+                }, {
+                    headers: {
+                        Authorization: "Bearer " + this.api_key,
+                        "Content-Type": ['application/json']
+                    },
+                });
+                if (response.status == 200) {
+                    console.log('success');
+                    return (0, parse_openai_response_1.parseOpenAiSuccessResponse)(response.data);
+                }
+                else {
+                    console.log('failed');
+                    return response.statusText;
+                }
+            }
+            catch (err) {
+                return (0, parse_openai_response_1.parseOpenAiFailureResponse)(err.response);
+            }
+        });
+    }
+}
+exports.OpenAiService = OpenAiService;

package/dist/typology_gen/generate_typology.js

@@ -11,23 +11,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateTypology = void 0;
 class GenerateTypology {
-    constructor(openAiService, prompt, content) {
+    constructor(openAiService, prompt, content, expected_fields) {
         this.prompt = '';
         this.content = '';
         this.openAiService = openAiService;
         this.prompt = prompt;
         this.content = content;
+        this.expectedFields = expected_fields.map((elem) => elem.toLowerCase());
     }
     generate() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b, _c;
             const response = yield ((_a = this.openAiService) === null || _a === void 0 ? void 0 : _a.sendRequest(this.prompt, this.content));
             response['type'] = 'typology';
             response.metadata = {
                 "req_time": response.generated_at,
                 "req_type": response.type,
-                "req_tokens": response.usage_data.prompt_tokens,
-                "res_tokens": response.usage_data.completion_tokens,
+                "req_tokens": (_b = response.usage_data) === null || _b === void 0 ? void 0 : _b.prompt_tokens,
+                "res_tokens": (_c = response.usage_data) === null || _c === void 0 ? void 0 : _c.completion_tokens,
             };
             if (response.status_code == 200) {
                 return this.parseTypologyOnSuccess(response);
@@ -43,14 +44,21 @@ class GenerateTypology {
         return {
             status_code: 200,
             metadata: responseData.metadata,
-            field: generatedContent.field,
+            field: this.parseFields(generatedContent.field),
             concepts: generatedContent.concepts,
             facts: generatedContent.facts,
             generate_cards: generatedContent.generate_cards,
             summary_cards: generatedContent.summary_cards,
-            type: responseData.type,
+            type: responseData.type
         };
     }
+    parseFields(fields) {
+        const fieldKeys = ['primary_field', 'secondary_field', 'tertiary_field'];
+        return fields.slice(0, 3).map((item, index) => ({
+            [fieldKeys[index]]: item,
+            "reconcile": !(this.expectedFields.includes(item.toLowerCase()))
+        }));
+    }
     parseTypologyOnFailure(responseData) {
         return __awaiter(this, void 0, void 0, function* () {
             responseData.metadata.status = 'failed';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "only_ever_generator",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "main": "dist/index.js",
   "scripts": {
     "start": "nodemon dist/index.js",

package/src/bootstrap/app.ts

@@ -1,78 +1,88 @@
-// import { ParseSourceContent } from "../class/parse/parse_source_content";
-// import { OpenAiService } from "../class/services/open_ai_service";
-// import { returnCardGenPrompt } from "../constants/prompts/card_gen_prompt";
-// import { returnTypologyPrompt } from "../constants/prompts/typology_prompt";
-// import { GenerateTypology } from "../typology_gen/generate_typology";
-// import { GenerateArgs } from "../utils/generate_args";
+import { GenerateCards } from "../card_gen/generate_cards";
+import { ParseSourceContent } from "../parse/parse_source_content";
+import { OpenAiService } from "../services/open_ai_service";
+import { returnCardGenPrompt } from "../constants/prompts/card_gen_prompt";
+import { returnTypologyPrompt } from "../constants/prompts/typology_prompt";
+import { GenerateTypology } from "../typology_gen/generate_typology";
+import { GenerateArgs } from "../utils/generate_args";
+import { returnFields } from "../constants/source_data";
+import { returnTypologyData } from "../parse/response_format_typology";
 
-// export class OnlyEverGenerator{
-//     public api_key: string = '';
-//     public openAiService: OpenAiService;
-//     parsedContent: string = '';
-//     constructor(apiKey:string, model: string, content: Array<any>){
-//         this.api_key = apiKey;
-//         this.openAiService = new OpenAiService(apiKey,model ?? 'gpt-3.5-turbo-1106');
-//         this.parsedContent = new ParseSourceContent(content).parse();
-//     };
 
-//     typologyResponse = {};
-//     cardgenResponse = {};
-//     summarizeResponse = {};
+/// OnlyEverGenerator 
+
+export class OnlyEverGenerator{
+    public api_key: string = '';
+    public openAiService: OpenAiService;
+    parsedContent: string = '';
+    expectedFields: Array<string>
+    constructor(apiKey:string, model: string, content: Array<any>, expected_fields: Array<string>){
+        this.api_key = apiKey;
+        this.openAiService = new OpenAiService(apiKey,model ?? 'gpt-3.5-turbo-1106');
+        this.parsedContent = new ParseSourceContent(content).parse();
+        this.expectedFields = returnFields()
+    };
+
+    typologyResponse = {};
+    cardgenResponse = {};
+    summarizeResponse = {};
 
     
     
 
-//     async generate( 
-//        generate_card : boolean = false,
-//        generate_typology: boolean =false,
-//     ): Promise<Array<any>> {
-//       let typologyPrompt = returnTypologyPrompt();
-//       let cardPrompt = returnCardGenPrompt();
-//       let args = new GenerateArgs(
-//         generate_card,
-//         generate_typology,
-//         false,
-//         {
-//           typology_prompt: typologyPrompt,
-//           card_gen_prompt: cardPrompt,
-//           summary_prompt: ''
-//         },
+    async generate( 
+       generate_typology: boolean =false,
+       generate_card : boolean = false,
+    ): Promise<Array<any>> {
+      let typologyPrompt = returnTypologyPrompt();
+      let cardPrompt = returnCardGenPrompt();
+      let args = new GenerateArgs(
+        generate_card,
+        generate_typology,
+        false,
+        {
+          typology_prompt: typologyPrompt,
+          card_gen_prompt: cardPrompt,
+          summary_prompt: ''
+        },
         
-//       );
-//         const responseToReturn = [];
-//         const whatNeedsToBeGenerated = args.getWhatNeedsToBeGenerated();
-//         for(let elem of whatNeedsToBeGenerated)
-//         if(elem == 'generate_tyopology'){
-//             this.typologyResponse = await this.generateTypology(args.prompts.typology_prompt ?? '');
-//             responseToReturn.push(this.typologyResponse);
-//         }else if(elem == 'generate_card'){
-
-//             this.cardgenResponse =  await this.generateCard(args.prompts.card_gen_prompt ?? '', this.parsedContent +  JSON.stringify(this.typologyResponse));
-//             responseToReturn.push(this.cardgenResponse);
-//         }
+      );
+        const responseToReturn = [];
+        const whatNeedsToBeGenerated = args.getWhatNeedsToBeGenerated();
+        for(let elem of whatNeedsToBeGenerated)
+        if(elem == 'generate_tyopology'){
+            this.typologyResponse = await this.generateTypology(args.prompts.typology_prompt ?? '');
+            responseToReturn.push(this.typologyResponse);
+        }else if(elem == 'generate_card'){
+            this.cardgenResponse =  await this.generateCard(args.prompts.card_gen_prompt ?? '', this.parsedContent +  JSON.stringify(this.typologyResponse));
+            responseToReturn.push(this.cardgenResponse);
+        }
 
-//         return responseToReturn;
+        return responseToReturn;
         
-//     }
+    }
     
-//     _returnParsedContent(){
-//         return this.parsedContent;
-//     }
+    _returnParsedContent(){
+        return this.parsedContent;
+    }
 
 
-//     async generateCard(prompt: string, content: string){
-//         let response =  await this.openAiService?.sendRequest(prompt,this.parsedContent);
-//         response['type'] = 'card_gen';
-//         return response;
-//     }
+    async generateCard(prompt: string, content: string){
+        let generateCards = new GenerateCards(this.openAiService);
+        let cardgenResponse =  await generateCards.generateCards(prompt ?? '', content);
+        // let response =  await this.openAiService?.sendRequest(prompt,this.parsedContent);
+        // response['type'] = 'card_gen';
+         return cardgenResponse;
+    }
 
-//     async generateTypology(prompt:string){
-//         let response =  await new GenerateTypology(
-//             this.openAiService,
-//             prompt,
-//             this.parsedContent
-//         ).generate();
-//         return response;
-//     }
+    async generateTypology(prompt:string){
+        let response =  await new GenerateTypology(
+            this.openAiService,
+            prompt,
+            this.parsedContent,
+            this.expectedFields,
+        ).generate();
+        return response;
+    }
     
-// }
+}

package/src/card_gen/generate_cards.ts

@@ -0,0 +1,192 @@
+import { OpenAiService } from "../services/open_ai_service";
+
+export class GenerateCards {
+  openAiService: OpenAiService;
+  constructor(openAiService: OpenAiService) {
+    this.openAiService = openAiService;
+  }
+
+  async generateCards(prompt: string, parsedContent: string) {
+    let response = await this.openAiService?.sendRequest(prompt, parsedContent);
+    console.log("response to card generation ", response);
+    response["type"] = "card_gen";
+       response.metadata = {
+        "req_time": response.generated_at,
+        "req_type": response.type,
+        "req_tokens": response.usage_data?.prompt_tokens,
+        "res_tokens": response.usage_data?.completion_tokens,
+    };
+      if(response.status_code == 200){
+        return this.parse(response);
+      } else {
+        return response;
+      }
+  }
+
+  parse(generatedData: any) {
+    const cardData = [];
+    const usage_data = generatedData.metadata;
+    const created_at = generatedData.created_at;
+    const status_code = generatedData.status_code;
+    const missing_concepts = generatedData.generated_content.missing_concepts;
+    const missing_facts = generatedData.generated_content.missing_facts;
+    const unparsedTestCards = generatedData.generated_content.test_cards;
+
+    for (let elem of unparsedTestCards) {
+      if (elem.type == "flash") {
+        cardData.push(this.parseFlashCard(elem));
+      } else if (elem.type == "mcq") {
+        cardData.push(this.parseMcqCard(elem));
+      } else if (elem.type == "cloze") {
+        cardData.push(this.parseClozeCard(elem));
+      } else if (elem.type == "match") {
+        cardData.push(this.parseMatchCard(elem));
+      }
+    }
+    usage_data["created_at"] = created_at;
+    usage_data["type"] = "card_gen";
+
+    return {
+      status_code: status_code,
+      metadata: usage_data,
+      missing_concepts: missing_concepts,
+      missing_facts: missing_facts,
+      cards_data: cardData,
+    };
+  }
+
+  parseFlashCard(data: any) {
+    let displayTitle = this.generateFlashCardDisplayTitle(
+      data.card_content.front,
+      data.card_content.back
+    );
+    let flashCardData = {
+      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,
+    };
+
+    return flashCardData;
+  }
+
+  generateFlashCardDisplayTitle(front: string, back: string) {
+    return `${front} ---- ${back}`;
+  }
+
+  parseMcqCard(data: any) {
+    let mcqAnswers = [];
+    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: data.type,
+      heading: data.card_reference,
+      displayTitle: displayTitle,
+      content: {
+        question: data.card_content.prompt,
+        answers: mcqAnswers,
+      },
+      concepts: data.concepts,
+      facts: data.facts,
+    };
+    return mcqCard;
+  }
+
+  generateMcqCardDisplayTitle(question: string, answers: any) {
+    let answersString = [];
+    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;
+  }
+
+  parseClozeCard(data: any) {
+    let displayTitle = this.generateClozeCardDisplayTitle(
+      data.card_content.text,
+      data.card_content.options
+    );
+    let clozeCardData = {
+      type: data.type,
+      heading: data.card_reference,
+      displayTitle: displayTitle,
+      content: {
+        question: data.card_content.text,
+        options: data.card_content.options,
+      },
+      concepts: data.concepts,
+      facts: data.facts,
+    };
+
+    return clozeCardData;
+  }
+
+  generateClozeCardDisplayTitle(question: string, answers: any) {
+    let optionsString = answers
+      .map((item: { option: any }) => item.option)
+      .join(", ");
+    return `${question} ---- ${optionsString}`;
+  }
+
+  parseMatchCard(cardData: any) {
+    let data = cardData.card_content;
+    const transformedData: { [key: string]: string[] } = {};
+
+    for (let key in data) {
+      if (data.hasOwnProperty(key)) {
+        transformedData[key] = [data[key]];
+        //     let value = data[key].replace(/[\[\]]/g, '');
+        //  let items = data[key].split(',').map((item: string) => item.trim());
+        //     map.set(key, items);
+        //   }
+      }
+      let displayTitle = this.generateMatchCardDisplayTitle(transformedData);
+      let matchCard = {
+        type: cardData.type,
+        heading: cardData.card_reference,
+        content: transformedData,
+        //  content: cardData.card_content,
+        displayTitle: displayTitle,
+        concepts: cardData.concepts,
+        facts: cardData.facts,
+      };
+
+      return matchCard;
+    }
+  }
+
+  generateMatchCardDisplayTitle(answers: any) {
+    let titles: string[] = [];
+    let counter = 65;
+    for (let key in answers) {
+      if (answers.hasOwnProperty(key)) {
+        let value = answers[key];
+        //     let items = value.split(',').map((item: string) => item.trim());
+        //     items.forEach((item: any) => {
+        let letter = String.fromCharCode(counter);
+        titles.push(`${letter}. ${key} -- ${value}`);
+        counter++;
+        //     });
+      }
+    }
+    let displayTitle = titles.join(",");
+    return displayTitle;
+  }
+}

package/src/constants/api_constants.ts

@@ -0,0 +1,3 @@
+export function openAiEndPoint(){
+    return 'https://api.openai.com/v1/chat/completions';
+}

package/src/constants/prompts/card_gen_prompt.ts

@@ -32,7 +32,7 @@ json
 
 **Criteria**
 •	Each test card must include at least one concept or fact.
-•	Flashcards must not exceed 15% of the total number of cards.
+•	Deprioritize the Flashcards, must not exceed 15% of the total number of cards.
 •	Each concept and fact must have at least one test card.
 
 Further instructions are provided below.
@@ -117,16 +117,17 @@ json
 json
 {
     "type": "cloze",
-    "card_content": {
-        "prompt": "Accidentals in music denote {{c0:notes}} that do not belong to the {{c1:scale}} or {{c2:mode}} indicated by the key signature.",
-        "options": [
-            {"option": "notes", "cloze": "c0"},
-            {"option": "scale", "cloze": "c1"},
-            {"option": "mode", "cloze": "c2"},
-            {"option": "chords", "cloze": "null"},
-            "... up to 8 choices"
+    "card_content":{
+    "text": "<clozed_text>",
+    "options": [
+            {"option" : "<cloze_0>", "cloze" : "<position_0>"},
+            {"option" : "<cloze_1>", "cloze" : "<position_1>,
+            {"option" : "<cloze_2>", "cloze" : "<position_2>"},
+            ....
+            {"option" : "<cloze_6>", "cloze" : "<position_6>"},
         ]
-    },
+
+    }
     "card_reference": "source_title#heading",
     "concepts": ["Concept1", "Concept2", "..."],
     "facts": ["Fact1", "Fact2", "..."]
@@ -144,10 +145,12 @@ json
 {
     "type": "match",
     "card_content": {
-        "right_choice 1": "left_choice 1",
-        "right_choice 2": "left_choice 2",
-        "... up to 8 total pairs"
-    },
+    "<left_text1>": "<right_text1>",
+    "<left_text2>": "<right_text2>",
+    "<left_text3>": "<right_text3>",
+    ...
+    "<left_text8>": "<right_text8>"
+}
     "card_reference": "source_title#heading",
     "concepts": ["Concept1", "Concept2", "..."],
     "facts": ["Fact1", "Fact2", "..."]
@@ -205,6 +208,10 @@ json
             "option: "notes",
             "cloze": "c0"
         },
+        {
+            "option: "chords",
+            "cloze": null
+        },
         {
             "option: "scale",
             "cloze": "c1"
@@ -213,17 +220,14 @@ json
             "option: "mode",
             "cloze": "c2"
         },
-        {
-            "option: "chords",
-            "cloze": "null"
-        },
+        
         {
             "option: "tilda",
-            "cloze": "null"
+            "cloze": null
         },
         {
             "option: "score",
-            "cloze": "null"
+            "cloze": null
         },
         "... up to a maximum of 8 choices total"
     ]
@@ -238,10 +242,11 @@ Maximum character length for an individual cloze: 90
 The schema for match type cards are as follows.
 json
 {
-    "right_choice 1": "left_choice 1",
-    "right_choice 2": "left_choice 2"
-    "right_choice 3": "left_choice 3"
-    "... up to 8 total pairs"
+    "<left_text1>": "<right_text1>",
+    "<left_text2>": "<right_text2>",
+    "<left_text3>": "<right_text3>",
+    ...
+    "<left_text8>": "<right_text8>"
 }
 
 Maximum character length for each item in a pair: 42
@@ -259,6 +264,7 @@ Once you are done generating the test cards, review the full list of concepts an
 	3.	Repeat this step until all concepts and facts are covered.
 
 Only stop generating test questions once you believe there is sufficient testing material for learners to fully understand the concepts and remember the facts. The same concept or fact can have multiple test cards, so continue creating test cards until you are confident that there are enough for learners to fully grasp the source material.
+
 `;
 
 
@@ -266,4 +272,3 @@ export function returnCardGenPrompt(){
   return promptString;
 }
 
-