only_ever_generator 0.5.5 → 0.5.6

package/dist/logger.js

@@ -1,5 +1,5 @@
 "use strict";
-/// 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
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
@@ -23,12 +23,12 @@ class ErrorLogger {
     log() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                let response = yield axios_1.default.post('https://us-east-1.aws.data.mongodb-api.com/app/oe-phase1-tkmsy/endpoint/oe_gen_logger', {
+                let response = yield axios_1.default.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']
-                    }
+                        "Content-Type": ["application/json"],
+                    },
                 });
                 return response;
             }

package/dist/parse/parse_card/parse_cloze_card.js

@@ -14,11 +14,14 @@ class ParseClozeCard {
             let parsedCorrectOptions = preparedData.options;
             let parsedIncorrectoptions = incorrectOptions.map((e) => {
                 return {
-                    "option": e,
-                    "cloze": "null"
+                    option: e,
+                    cloze: "null",
                 };
             });
-            const finalParsedOptions = [...parsedCorrectOptions, ...parsedIncorrectoptions];
+            const finalParsedOptions = [
+                ...parsedCorrectOptions,
+                ...parsedIncorrectoptions,
+            ];
             let clozeCardData = {
                 type: {
                     category: "learning",
@@ -44,8 +47,7 @@ class ParseClozeCard {
         try {
             let optionsString = "";
             if (answers.length !== 0) {
-                optionsString = answers
-                    .join(", ");
+                optionsString = answers.join(", ");
             }
             return `${question} ---- ${optionsString}`;
         }
@@ -71,16 +73,16 @@ class ParseClozeCard {
                 if (idx !== -1) {
                     let cloze = `c${idx}`;
                     finalCorrectOptions.push({
-                        "option": p1,
-                        "cloze": cloze,
+                        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
+                prompt: transformed,
+                options: finalCorrectOptions,
             };
         }
         catch (e) {

package/dist/parse/parse_card/parse_flash_cards.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseFlashCard = void 0;
+class ParseFlashCard {
+    parse(data) {
+        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, back) {
+        return `${front} ---- ${back}`;
+    }
+}
+exports.ParseFlashCard = ParseFlashCard;

package/dist/parse/parse_card_response.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParseCardResponse = void 0;
 const logger_1 = require("../logger");
 const parse_cloze_card_1 = require("./parse_card/parse_cloze_card");
+const parse_flash_cards_1 = require("./parse_card/parse_flash_cards");
 const parse_match_card_1 = require("./parse_card/parse_match_card");
 const parse_mcq_card_1 = require("./parse_card/parse_mcq_card");
 class ParseCardResponse {
@@ -15,7 +16,7 @@ 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 parse_flash_cards_1.ParseFlashCard().parse(elem);
                         if (flashCard != null && flashCard) {
                             flashCard.heading = this._getCardReference(flashCard, sourceTaxonomy);
                             cardData.push(flashCard);
@@ -74,33 +75,6 @@ class ParseCardResponse {
             };
         }
     }
-    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: "",
-                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, back) {
-        return `${front} ---- ${back}`;
-    }
     _getCardReference(generatedCardData, sourceTaxonomy) {
         var _a, _b, _c, _d;
         const cardConcepts = (_a = generatedCardData.concepts) !== null && _a !== void 0 ? _a : [];
@@ -110,17 +84,20 @@ class ParseCardResponse {
         const sourceFacts = (_d = sourceTaxonomy.facts) !== null && _d !== void 0 ? _d : [];
         const mappedSourceConcepts = sourceConcepts.map((elem) => {
             return {
-                "text": elem.concept_text,
+                text: elem.concept_text,
                 reference: elem.reference,
             };
         });
         const mappedSourceFacts = sourceFacts.map((elem) => {
             return {
-                "text": elem.fact_text,
+                text: elem.fact_text,
                 reference: elem.reference,
             };
         });
-        const compinedConceptsAndFacts = [...mappedSourceConcepts, ...mappedSourceFacts];
+        const compinedConceptsAndFacts = [
+            ...mappedSourceConcepts,
+            ...mappedSourceFacts,
+        ];
         const firstMatchedConcept = compinedConceptsAndFacts.find((elem) => combinedCardFactsAndConcepts.includes(elem.text));
         if (firstMatchedConcept) {
             return firstMatchedConcept.reference;

package/dist/parse/parse_source_content.js

@@ -12,8 +12,17 @@ class ParseSourceContent {
         //     taxonomy: source.source_taxonomy,
         //     type: source.source_type
         //   },
-        this.titles_to_remove = ['See also', 'References', 'Further reading', 'External links', 'Notes and references', 'Bibliography', 'Notes', 'Cited sources'];
-        this.block_types_toremove = ['table', 'empty_line'];
+        this.titles_to_remove = [
+            "See also",
+            "References",
+            "Further reading",
+            "External links",
+            "Notes and references",
+            "Bibliography",
+            "Notes",
+            "Cited sources",
+        ];
+        this.block_types_toremove = ["table", "empty_line"];
         this.content = sourceContent;
     }
     parseData() {
@@ -37,7 +46,8 @@ class ParseSourceContent {
     removeSectionsByTitle(data) {
         let dataAfterRemoving = [];
         for (let elem of data) {
-            if (elem.block_type == 'heading' && this.titles_to_remove.includes(elem.content)) {
+            if (elem.block_type == "heading" &&
+                this.titles_to_remove.includes(elem.content)) {
                 continue;
             }
             /// remove unwanted blcok types , for now `table` and `empty_line`
@@ -53,26 +63,26 @@ class ParseSourceContent {
     }
     sanitizeTextContent(content) {
         // Remove newline characters
-        content = content.replace(/\\n/g, ' ');
+        content = content.replace(/\\n/g, " ");
         // Remove internal link references, keeping only the link text
         // Pattern explanation: [[link|text|index|wiki]] --> text
-        content = content.replace(/\[\[.*?\|(.*?)\|.*?\|wiki\]\]/g, '$1');
+        content = content.replace(/\[\[.*?\|(.*?)\|.*?\|wiki\]\]/g, "$1");
         // Remove external links, keeping only the link text
         // Pattern explanation: [url text] --> text
-        content = content.replace(/\[http[s]?:\/\/[^\s]+ ([^\]]+)\]/g, '$1');
+        content = content.replace(/\[http[s]?:\/\/[^\s]+ ([^\]]+)\]/g, "$1");
         // Remove Markdown link references, keeping only the link text
         // Pattern explanation: ![link text](url) --> link text
-        content = content.replace(/\!\[([^\]]+)\]\([^\)]+\)/g, '$1');
+        content = content.replace(/\!\[([^\]]+)\]\([^\)]+\)/g, "$1");
         return content;
     }
     sanitizeBlocks(blocks) {
         let sanitizedBlocks = [];
-        blocks = blocks.filter((item) => item.block_type != 'table');
-        blocks.forEach(block => {
+        blocks = blocks.filter((item) => item.block_type != "table");
+        blocks.forEach((block) => {
             let sanitizedBlock = {};
             for (let key in block) {
                 let value = block[key];
-                if (typeof value === 'string') {
+                if (typeof value === "string") {
                     sanitizedBlock[key] = this.sanitizeTextContent(value);
                 }
                 else if (Array.isArray(value)) {
@@ -92,10 +102,10 @@ class ParseSourceContent {
         data.forEach((e) => {
             let combinedContent = this.cleanTranscript(e);
             finalChapters.push({
-                "startTime": e.startTime,
-                "endTime": e.endTime,
-                "content": combinedContent,
-                "title": e.content
+                startTime: e.startTime,
+                endTime: e.endTime,
+                content: combinedContent,
+                title: e.content,
             });
         });
         return finalChapters;
@@ -108,13 +118,13 @@ class ParseSourceContent {
     // remove non-essential content
     cleanTranscript(data) {
         var _a;
-        let finalContent = '';
+        let finalContent = "";
         let children = (_a = data.children) !== null && _a !== void 0 ? _a : [];
         children.forEach((e) => {
             let content = (e.content || "").trim();
             if (this.isNonSpeech(content))
                 return;
-            content = content.replace(/\s+/g, ' ');
+            content = content.replace(/\s+/g, " ");
             finalContent += content;
         });
         return finalContent;
@@ -127,7 +137,7 @@ class ParseSourceContent {
         let bucketEndTime = null;
         let bucketContent = [];
         let bucketDuration = 0.0;
-        data.forEach(entry => {
+        data.forEach((entry) => {
             const startTime = entry.start_time;
             const endTime = entry.end_time;
             const content = entry.content;
@@ -139,7 +149,7 @@ class ParseSourceContent {
                 bucketContent.push(content);
                 bucketDuration = entryDuration;
             }
-            else if ((bucketDuration + entryDuration) <= maxDuration) {
+            else if (bucketDuration + entryDuration <= maxDuration) {
                 // Add to current bucket
                 bucketEndTime = endTime;
                 bucketContent.push(content);
@@ -150,7 +160,7 @@ class ParseSourceContent {
                 const collapsedEntry = {
                     start_time: bucketStartTime,
                     end_time: bucketEndTime,
-                    content: bucketContent.join(' ')
+                    content: bucketContent.join(" "),
                 };
                 collapsedData.push(collapsedEntry);
                 // Start new bucket with current entry
@@ -165,7 +175,7 @@ class ParseSourceContent {
             const collapsedEntry = {
                 start_time: bucketStartTime,
                 end_time: bucketEndTime,
-                content: bucketContent.join(' ')
+                content: bucketContent.join(" "),
             };
             collapsedData.push(collapsedEntry);
         }

package/dist/parse/response_format_typology.js

@@ -2,18 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.returnTypologyData = returnTypologyData;
 const typologyResponse = {
-    "usage_data": {
-        "prompt_tokens": 11611,
-        "completion_tokens": 441,
-        "total_tokens": 12052
+    usage_data: {
+        prompt_tokens: 11611,
+        completion_tokens: 441,
+        total_tokens: 12052,
     },
-    "generated_content": {
-        "field": [
+    generated_content: {
+        field: [
             "Sciences",
             "Technology & Engineering",
-            "Education, Learning & Personal Development"
+            "Education, Learning & Personal Development",
         ],
-        "concepts": [
+        concepts: [
             "Electrolysis",
             "Faraday's Laws of Electrolysis",
             "Electrolytic Cell",
@@ -21,25 +21,25 @@ const typologyResponse = {
             "Oxidation and Reduction at the Electrodes",
             "Electrolysis of Water",
             "Electrolysis of Carbon Dioxide",
-            "Electrocrystallization"
+            "Electrocrystallization",
         ],
-        "facts": [
+        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."
+            "The electrochemical reduction of carbon dioxide can produce value-added chemicals such as methane, ethylene, and ethanol.",
         ],
-        "generate_cards": true,
-        "summary_cards": [
+        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."
-        ]
+            "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"
+    generated_at: "Tue, 20 Jan 1970 21:17:46 GMT",
 };
 function returnTypologyData() {
     return typologyResponse;

package/dist/services/open_ai_service.js

@@ -26,28 +26,31 @@ class OpenAiService {
             try {
                 let message = [
                     {
-                        "role": "system", "content": prompt
-                    }, {
-                        "role": "user", "content": content
-                    }
+                        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" },
+                    model: this.model,
+                    messages: message,
+                    response_format: { type: "json_object" },
                 }, {
                     headers: {
                         Authorization: "Bearer " + this.api_key,
-                        "Content-Type": ['application/json']
+                        "Content-Type": ["application/json"],
                     },
                 });
                 if (response.status == 200) {
-                    console.log('success');
+                    console.log("success");
                     return (0, parse_openai_response_1.parseOpenAiSuccessResponse)(response.data);
                 }
                 else {
-                    console.log('failed');
+                    console.log("failed");
                     return response.statusText;
                 }
             }

package/dist/typology_gen/generate_typology.js

@@ -13,8 +13,8 @@ exports.GenerateTypology = void 0;
 const logger_1 = require("../logger");
 class GenerateTypology {
     constructor(openAiService, prompt, content, expected_fields) {
-        this.prompt = '';
-        this.content = '';
+        this.prompt = "";
+        this.content = "";
         this.openAiService = openAiService;
         this.prompt = prompt;
         this.content = content;
@@ -22,16 +22,17 @@ class GenerateTypology {
     }
     generate() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             try {
                 const response = yield ((_a = this.openAiService) === null || _a === void 0 ? void 0 : _a.sendRequest(this.prompt, this.content));
-                response['type'] = 'typology';
+                response["type"] = "typology";
                 response.metadata = {
-                    "req_time": (_b = response.generated_at) !== null && _b !== void 0 ? _b : new Date(),
-                    "req_type": response.type,
-                    "req_tokens": (_c = response.usage_data) === null || _c === void 0 ? void 0 : _c.prompt_tokens,
-                    "res_tokens": (_d = response.usage_data) === null || _d === void 0 ? void 0 : _d.completion_tokens,
-                    "model": this.openAiService.model
+                    req_time: (_b = response.generated_at) !== null && _b !== void 0 ? _b : new Date(),
+                    req_type: response.type,
+                    req_tokens: (_c = response.usage_data) === null || _c === void 0 ? void 0 : _c.prompt_tokens,
+                    res_tokens: (_d = response.usage_data) === null || _d === void 0 ? void 0 : _d.completion_tokens,
+                    prompt_tokens_details: (_e = response.usage_data) === null || _e === void 0 ? void 0 : _e.prompt_tokens_details,
+                    model: this.openAiService.model,
                 };
                 if (response.status_code == 200) {
                     return this.parseTypologyOnSuccess(response);
@@ -43,8 +44,8 @@ class GenerateTypology {
             }
             catch (e) {
                 yield new logger_1.ErrorLogger({
-                    "type": 'typology_parsing',
-                    "data": e.message
+                    type: "typology_parsing",
+                    data: e.message,
                 }).log();
             }
         });
@@ -60,19 +61,19 @@ class GenerateTypology {
             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'];
+        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()))
+            reconcile: !this.expectedFields.includes(item.toLowerCase()),
         }));
     }
     parseTypologyOnFailure(responseData) {
         return __awaiter(this, void 0, void 0, function* () {
-            responseData.metadata.status = 'failed';
+            responseData.metadata.status = "failed";
             return {
                 status_code: responseData.status_code,
                 metadata: responseData.metadata,

package/dist/utils/generate_args.js

@@ -13,13 +13,13 @@ class GenerateArgs {
     getWhatNeedsToBeGenerated() {
         let returnData = [];
         if (this.generate_typology == true) {
-            returnData.push('generate_tyopology');
+            returnData.push("generate_tyopology");
         }
         if (this.generate_summary == true) {
-            returnData.push('generate_summary');
+            returnData.push("generate_summary");
         }
         if (this.generate_card == true) {
-            returnData.push('generate_card');
+            returnData.push("generate_card");
         }
         return returnData;
     }

package/dist/utils/parse_openai_response.js

@@ -7,17 +7,17 @@ function parseOpenAiSuccessResponse(responseData) {
     let usuage = responseData.usage;
     let createdTime = responseData.created;
     return {
-        'status_code': 200,
-        'usage_data': usuage,
-        'generated_content': choices,
-        'generated_at': new Date(createdTime * 1000)
+        status_code: 200,
+        usage_data: usuage,
+        generated_content: choices,
+        generated_at: new Date(createdTime * 1000),
     };
 }
 function parseOpenAiFailureResponse(errorResponse) {
     var _a, _b;
-    // let statusCode = 
+    // let statusCode =
     return {
-        'status_code': errorResponse.status,
-        'message': (_b = (_a = errorResponse.data) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.code
+        status_code: errorResponse.status,
+        message: (_b = (_a = errorResponse.data) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.code,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "only_ever_generator",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "main": "dist/index.js",
   "scripts": {
     "start": "npm run build && nodemon dist/index.js",