only_ever_generator 1.0.3 → 1.0.5

package/src/typology_gen/generate_typology.ts

@@ -1,14 +1,103 @@
-import { OpenAiService } from "../class/services/open_ai_service";
-import { returnTypologyData } from "../parse_response/response_format_typology";
-// import { openAIRequest } from "../service/open_ai_request.js";
-
-export async function generateTypology(openAiService: OpenAiService,  prompt: String,message:String){
-    try{
-        // let openAiService = new OpenAiService(config.openAIKey)
-        let response = await openAiService.sendRequest(prompt,message);
-        // let response = returnTypologyData();
+import { OpenAiService } from "../services/open_ai_service";
+import { returnTypologyData } from "../parse/response_format_typology";
+import { ErrorLogger } from "../logger";
+
+export class GenerateTypology {
+  public openAiService: OpenAiService;
+  public prompt: string = "";
+  public content: string = "";
+  expectedFields: Array<string>;
+  constructor(
+    openAiService: OpenAiService,
+    prompt: string,
+    content: string,
+    expected_fields: Array<string>
+  ) {
+    this.openAiService = openAiService;
+    this.prompt = prompt;
+    this.content = content;
+    this.expectedFields = expected_fields.map((elem: string) =>
+      elem.toLowerCase()
+    );
+  }
+  async generate() {
+    try {
+      const response = await this.openAiService?.sendRequest(
+        this.prompt,
+        this.content
+      );
+      response["request_type"] = {
+        type: "breadth",
+        n: 1,
+      };
+      response.metadata = {
+        req_time: response.generated_at ?? new Date(),
+        req_type: {
+          type: "breadth",
+          n: 1,
+        },
+        req_tokens: response.usage_data?.prompt_tokens,
+        res_tokens: response.usage_data?.completion_tokens,
+        prompt_tokens_details: response.usage_data?.prompt_tokens_details,
+        model: this.openAiService.model,
+      };
+      if (response.status_code == 200) {
+        return this.parseTypologyOnSuccess(response);
+      } else {
+        response.metadata.err_message = response.message;
         return response;
-    }catch(e){
-       throw e;
+      }
+    } catch (e: any) {
+      await new ErrorLogger({
+        type: "typology_parsing",
+        data: e.message,
+      }).log();
     }
-}
+  }
+
+  parseTypologyOnSuccess(responseData: any) {
+    responseData.metadata.status = "completed";
+    const generatedContent = responseData.generated_content;
+    const concepts = generatedContent.concepts.map((e: any) => {
+      return {
+        text: e.concept_text,
+        type: "concept",
+        reference: e.reference,
+      };
+    });
+    const facts = generatedContent.facts.map((e: any) => {
+      return {
+        text: e.fact_text,
+        type: "fact",
+        reference: e.reference,
+      };
+    });
+
+    return {
+      status_code: 200,
+      metadata: [responseData.metadata],
+      field: this.parseFields(generatedContent.field),
+      concepts_facts: [...concepts, ...facts],
+      generate_cards: generatedContent.generate_cards,
+      summary_cards: generatedContent.summary_cards,
+      // type: responseData.type,
+    };
+  }
+
+  parseFields(fields: Array<string>) {
+    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()),
+    }));
+  }
+
+  async parseTypologyOnFailure(responseData: any) {
+    responseData.metadata.status = "failed";
+
+    return {
+      status_code: responseData.status_code,
+      metadata: responseData.metadata,
+    };
+  }
+}

package/src/utils/generate_args.ts

@@ -0,0 +1,29 @@
+export class GenerateArgs {
+  public generate_card: boolean = false;
+  public generate_typology: boolean = false;
+  public generate_summary: boolean = false;
+
+  constructor(
+    generate_card: boolean,
+    generate_typology: boolean,
+    generate_summary: boolean
+  ) {
+    this.generate_card = generate_card;
+    this.generate_typology = generate_typology;
+    this.generate_summary = generate_summary;
+  }
+
+  getWhatNeedsToBeGenerated() {
+    let returnData = [];
+    if (this.generate_typology == true) {
+      returnData.push("generate_tyopology");
+    }
+    if (this.generate_summary == true) {
+      returnData.push("generate_summary");
+    }
+    if (this.generate_card == true) {
+      returnData.push("generate_card");
+    }
+    return returnData;
+  }
+}

package/src/utils/parse_openai_response.ts

@@ -1,21 +1,19 @@
-export function parseOpenAiSuccessResponse(responseData: any){
-    let choices =  JSON.parse(responseData.choices[0].message.content);
-    let usuage = responseData.usage;
-    let createdTime = responseData.created;
-    return {
-        'status_code': 200,
-        'usage_data': usuage,
-        'generated_content':choices,
-        'generated_at': createdTime
-    }
+export function parseOpenAiSuccessResponse(responseData: any) {
+  let choices = JSON.parse(responseData.choices[0].message.content);
+  let usuage = responseData.usage;
+  let createdTime = responseData.created;
+  return {
+    status_code: 200,
+    usage_data: usuage,
+    generated_content: choices,
+    generated_at: new Date(createdTime * 1000),
+  };
 }
 
-export function parseOpenAiFailureResponse(errorResponse: any){
-    let usuage = errorResponse.usuage;
-    // let statusCode = 
-    return {
-        'status_code': errorResponse.status,
-
-
-    }
-}
+export function parseOpenAiFailureResponse(errorResponse: any) {
+  // let statusCode =
+  return {
+    status_code: errorResponse.status,
+    message: errorResponse.data?.error?.code,
+  };
+}

package/tsconfig.json

@@ -5,8 +5,13 @@
     "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
     "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
     "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": false,
     "rootDir": "./src",
-    "outDir": "./dist" /* Enable all strict type-checking options. */
+    "outDir": "./dist", /* Enable all strict type-checking options. */
+    "sourceMap": true
   },
-  "exclude": ["./src/*/*.d.ts"]
-}
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts"]
+}  

package/dist/class/parse/parse_source_content.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParseSourceContent = void 0;
-class ParseSourceContent {
-    constructor(sourceContent) {
-        this.titles_to_remove = ['See also', 'References', 'Further reading', 'External links', 'Notes and references', 'Bibliography', 'Notes', 'Cited sources'];
-        this.content = sourceContent;
-    }
-    parse() {
-        let dataAfterRemovingUnWantedBlocks = this.removeSectionsByTitle(this.content);
-        let afterSanitized = this.sanitizeBlocks(dataAfterRemovingUnWantedBlocks);
-        return JSON.stringify(afterSanitized);
-    }
-    removeSectionsByTitle(data) {
-        let dataAfterRemoving = [];
-        for (let elem of data) {
-            if (elem.block_type == 'heading' && this.titles_to_remove.includes(elem.content)) {
-                continue;
-            }
-            if (elem.children) {
-                elem.children = this.removeSectionsByTitle(elem.children);
-            }
-            dataAfterRemoving.push(elem);
-        }
-        return dataAfterRemoving;
-    }
-    sanitizeWikiContent(content) {
-        // Remove newline characters
-        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');
-        // Remove external links, keeping only the link text
-        // Pattern explanation: [url text] --> text
-        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');
-        return content;
-    }
-    sanitizeBlocks(blocks) {
-        let sanitizedBlocks = [];
-        blocks.forEach(block => {
-            let sanitizedBlock = {};
-            for (let key in block) {
-                let value = block[key];
-                if (typeof value === 'string') {
-                    sanitizedBlock[key] = this.sanitizeWikiContent(value);
-                }
-                else if (Array.isArray(value)) {
-                    sanitizedBlock[key] = this.sanitizeBlocks(value);
-                }
-                else {
-                    sanitizedBlock[key] = value;
-                }
-            }
-            sanitizedBlocks.push(sanitizedBlock);
-        });
-        return sanitizedBlocks;
-    }
-}
-exports.ParseSourceContent = ParseSourceContent;

package/dist/class/services/open_ai_service.js

@@ -1,25 +0,0 @@
-"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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAiService = void 0;
-const open_ai_request_1 = require("../../service/open_ai_request");
-class OpenAiService {
-    constructor(apiKey, model) {
-        this.api_key = apiKey;
-        this.model = model;
-    }
-    sendRequest(prompt, content) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield (0, open_ai_request_1.openAIRequest)(content, prompt, this.api_key, this.model);
-        });
-    }
-}
-exports.OpenAiService = OpenAiService;

package/dist/parse_response/response_format_card.js

@@ -1,210 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseResponse = exports.returnResponse = void 0;
-const responseData = {
-    "flash_cards": [
-        {
-            "question": "What is the primary function of the 'Electrolysis'?",
-            "answer": "Electrolysis is the passing of a direct electric current through an electrolyte producing chemical reactions at the electrodes and decomposition of the materials.",
-            "heading": "Overview"
-        },
-        {
-            "question": "What did Michael Faraday discover while studying the process of electrolysis under Humphry Davy?",
-            "answer": "Michael Faraday discovered two laws of electrolysis.",
-            "heading": "History"
-        },
-        {
-            "question": "What can electrolysis be used for in the manufacturing sector?",
-            "answer": "Electrolysis can be used for electroplating and electrochemical machining.",
-            "heading": "Manufacturing processes"
-        },
-        {
-            "question": "In the context of electrolysis, what does the term 'Decomposition potential' refer to?",
-            "answer": "Decomposition potential or decomposition voltage refers to the minimum voltage between anode and cathode of an electrolytic cell needed for electrolysis to occur.",
-            "heading": "Decomposition potential"
-        }
-    ],
-    "mcqs": [
-        {
-            "question": "What is the primary purpose of 'Electrometallurgy'?",
-            "answers": [
-                {
-                    "answer": "Production of aluminium",
-                    "is_correct": true
-                },
-                {
-                    "answer": "Chlorine production",
-                    "is_correct": false
-                },
-                {
-                    "answer": "Purifying copper",
-                    "is_correct": false
-                },
-                {
-                    "answer": "Rust removal",
-                    "is_correct": false
-                },
-                {
-                    "answer": "Hydrogen production",
-                    "is_correct": false
-                }
-            ],
-            "heading": "Industrial uses"
-        },
-        {
-            "question": "What can electrolysis be used for in the context of batteries?",
-            "answers": [
-                {
-                    "answer": "Spontaneous redox reactions",
-                    "is_correct": true
-                },
-                {
-                    "answer": "Energy-releasing reactions",
-                    "is_correct": false
-                },
-                {
-                    "answer": "Disinfectant production",
-                    "is_correct": false
-                },
-                {
-                    "answer": "Fuel production",
-                    "is_correct": false
-                },
-                {
-                    "answer": "Gas diffusion in reactors",
-                    "is_correct": false
-                }
-            ],
-            "heading": "Related processes"
-        }
-    ],
-    "cloze_cards": [
-        {
-            "question": "Electrolysis is the passing of a {{c0:direct electric current}} through an {{c1:electrolyte}} producing {{c2:chemical reactions}} at the {{c3:electrodes}} and {{c4:decomposition}} of the materials.",
-            "options": [
-                {
-                    "option": "direct electric current",
-                    "cloze": "c0"
-                },
-                {
-                    "option": "electrolyte",
-                    "cloze": "c1"
-                },
-                {
-                    "option": "chemical reactions",
-                    "cloze": "c2"
-                },
-                {
-                    "option": "electrodes",
-                    "cloze": "c3"
-                },
-                {
-                    "option": "decomposition",
-                    "cloze": "c4"
-                },
-                {
-                    "option": "metallic objects",
-                    "cloze": null
-                }
-            ]
-        },
-        {
-            "question": "In electrolysis, the decomposition potential or decomposition voltage refers to the minimum voltage between {{c0:anode}} and {{c1:cathode}} of an electrolytic cell needed for electrolysis to occur.",
-            "options": [
-                {
-                    "option": "anode",
-                    "cloze": "c0"
-                },
-                {
-                    "option": "cathode",
-                    "cloze": "c1"
-                },
-                {
-                    "option": "electrolyte",
-                    "cloze": null
-                },
-                {
-                    "option": "chemical reactions",
-                    "cloze": null
-                },
-                {
-                    "option": "oxygen",
-                    "cloze": null
-                },
-                {
-                    "option": "hydrogen",
-                    "cloze": null
-                }
-            ]
-        }
-    ]
-};
-function returnResponse() {
-    return responseData;
-}
-exports.returnResponse = returnResponse;
-function parseResponse() {
-    let cardData = [];
-    let data = returnResponse();
-    let keys = Object.keys(data);
-    if (keys) {
-        for (let elem of keys) {
-            if (elem == 'flash_cards') {
-                cardData.push(...parseFlashCard(data.flash_cards));
-            }
-            else if (elem == 'cloze_cards') {
-                cardData.push(...parseClozeCards(data.cloze_cards));
-            }
-            else if (elem == 'mcqs') {
-                cardData.push(...parseMcq(data.mcqs));
-            }
-        }
-    }
-    return cardData;
-}
-exports.parseResponse = parseResponse;
-/// takes array of 
-function parseFlashCard(cards) {
-    let flashCardData = [];
-    for (let elem of cards) {
-        flashCardData.push({
-            "type": "flash",
-            "heading": elem.heading,
-            "content": JSON.stringify({
-                "front_content": elem.question,
-                "back_content": elem.answer
-            })
-        });
-    }
-    return flashCardData;
-}
-/// takes array of 
-function parseMcq(cardsData) {
-    let mcqCards = [];
-    for (let elem of cardsData) {
-        mcqCards.push({
-            "type": "mcq",
-            "heading": elem.heading,
-            "content": JSON.stringify({
-                "question": elem.question,
-                "answers": elem.answers
-            })
-        });
-    }
-    return mcqCards;
-}
-/// takes array of 
-function parseClozeCards(cardsData) {
-    let clozeCards = [];
-    for (let elem of cardsData) {
-        clozeCards.push({
-            "type": "cloze",
-            "heading": elem.heading,
-            "content": JSON.stringify({
-                "question": elem.question,
-                "options": elem.options
-            })
-        });
-    }
-    return clozeCards;
-}

package/dist/service/open_ai_request.js

@@ -1,58 +0,0 @@
-"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.openAIRequest = void 0;
-const axios_1 = __importDefault(require("axios"));
-const parse_openai_response_js_1 = require("../utils/parse_openai_response.js");
-function openAIRequest(content, prompt, token, model) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            let message = [
-                {
-                    "role": "system", "content": prompt
-                }, {
-                    "role": "user", "content": content
-                }
-            ];
-            const url = 'https://api.openai.com/v1/chat/completions';
-            let response = yield axios_1.default.post(url, 
-            //data
-            {
-                "model": model,
-                "messages": message,
-                "response_format": { "type": "json_object" },
-            }, 
-            ///config
-            {
-                headers: {
-                    Authorization: "Bearer " + token,
-                    "Content-Type": ['application/json']
-                },
-            });
-            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');
-                return response.statusText;
-            }
-        }
-        catch (err) {
-            return (0, parse_openai_response_js_1.parseOpenAiFailureResponse)(err.response);
-        }
-    });
-}
-exports.openAIRequest = openAIRequest;

package/src/class/parse/parse_source_content.ts

@@ -1,71 +0,0 @@
-export class ParseSourceContent{
-    public content: Array<any>;
-
-    titles_to_remove = ['See also', 'References', 'Further reading', 'External links', 'Notes and references', 'Bibliography', 'Notes', 'Cited sources'];
-
-    constructor(sourceContent:Array<any>){
-        this.content = sourceContent;
-    }
-
-    parse() {
-        let dataAfterRemovingUnWantedBlocks = this.removeSectionsByTitle(this.content);
-        let afterSanitized = this.sanitizeBlocks(dataAfterRemovingUnWantedBlocks);
-        return JSON.stringify(afterSanitized);    
-    }
-
-    removeSectionsByTitle(data: Array<any>){
-        let dataAfterRemoving = [];
-        for(let elem of data){
-            if(elem.block_type == 'heading' &&   this.titles_to_remove.includes(elem.content)){
-                continue;
-            }
-            if(elem.children){
-                elem.children = this.removeSectionsByTitle(elem.children)
-            }
-            dataAfterRemoving.push(elem)
-            
-        }
-        return dataAfterRemoving;
-    }
-    
-
-     sanitizeWikiContent(content: String) {
-        // Remove newline characters
-        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');
-    
-        // Remove external links, keeping only the link text
-        // Pattern explanation: [url text] --> text
-        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');
-    
-        return content;
-    }
-
-    sanitizeBlocks(blocks: Array<any>) {
-        let sanitizedBlocks = <any>[] ;
-        blocks.forEach(block => {
-            let sanitizedBlock: any = {};
-            for (let key in block) {
-                let value = block[key];
-                if (typeof value === 'string') {
-                    sanitizedBlock[key] = this.sanitizeWikiContent(value);
-                } else if (Array.isArray(value)) {
-                    sanitizedBlock[key] = this.sanitizeBlocks(value);
-                } else {
-                    sanitizedBlock[key] = value;
-                }
-            }
-            sanitizedBlocks.push(sanitizedBlock);
-        });
-        return sanitizedBlocks;
-    }
-    
-    
-}

package/src/class/services/open_ai_service.ts

@@ -1,18 +0,0 @@
-import { openAIRequest } from "../../service/open_ai_request";
-
-
-export class OpenAiService{
-    public api_key: String;
-    public model: String;
-    
-
-    constructor(apiKey: String, model:String){
-        this.api_key = apiKey;
-        this.model =model
-    }
-
-    async sendRequest(prompt: String,content: String){
-        return await openAIRequest(content,prompt,this.api_key,this.model);
-    } 
-}
-