only_ever_generator 0.2.6 → 0.2.8

package/src/parse/response_format_typology.ts

@@ -1,44 +1,44 @@
-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"
-  };
-
-  export function returnTypologyData(){
-    return typologyResponse as any;
+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"
+  };
+
+  export function returnTypologyData(){
+    return typologyResponse as any;
   }

package/src/services/open_ai_service.ts

@@ -1,54 +1,55 @@
-import axios from "axios";
-import { parseOpenAiFailureResponse, parseOpenAiSuccessResponse } from "../utils/parse_openai_response";
-import { openAiEndPoint } from "../constants/api_constants";
-
-
-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){
-        try{
-            let message = [
-                {
-                    "role": "system", "content": prompt
-                },{
-                    "role": "user", "content": content
-                }
-            ];
-            const url = openAiEndPoint();
-            let response = await axios.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 parseOpenAiSuccessResponse(response.data) as any
-        
-            }else{
-                console.log('failed');
-                return response.statusText as any;
-            }}catch (err:any) {
-                return parseOpenAiFailureResponse(err.response);
-            }
-    } 
-}
-
+import axios from "axios";
+import { parseOpenAiFailureResponse, parseOpenAiSuccessResponse } from "../utils/parse_openai_response";
+import { openAiEndPoint } from "../constants/api_constants";
+import { ErrorLogger } from "../logger";
+
+
+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){
+        try{
+            let message = [
+                {
+                    "role": "system", "content": prompt
+                },{
+                    "role": "user", "content": content
+                }
+            ];
+            const url = openAiEndPoint();
+            let response = await axios.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 parseOpenAiSuccessResponse(response.data) as any
+        
+            }else{
+                console.log('failed');
+                return response.statusText as any;
+            }}catch (err:any) {
+                return parseOpenAiFailureResponse(err.response);
+            }
+    } 
+}
+

package/src/typology_gen/generate_typology.ts

@@ -1,65 +1,72 @@
-import { OpenAiService } from "../services/open_ai_service";
-import { returnTypologyData } from "../parse/response_format_typology";
-
-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(){
-      const response =  await this.openAiService?.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,
-    };
-      if(response.status_code == 200){
-        return this.parseTypologyOnSuccess(response);
-      } else {
-        return response;
-      }
-    }
-
-
-    parseTypologyOnSuccess(responseData : any){
-        responseData.metadata.status = "completed";
-        const generatedContent = responseData.generated_content;
-        return {
-            status_code: 200,
-            metadata: responseData.metadata,
-            field: this.parseFields(generatedContent.field),
-            concepts: generatedContent.concepts,
-            facts: generatedContent.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,
-        }
-    }
-
+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['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,
+    };
+      if(response.status_code == 200){
+        return this.parseTypologyOnSuccess(response);
+      } else {
+        return response;
+      }} 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;
+        return {
+            status_code: 200,
+            metadata: responseData.metadata,
+            field: this.parseFields(generatedContent.field),
+            concepts: generatedContent.concepts,
+            facts: generatedContent.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

@@ -1,38 +1,29 @@
-export class GenerateArgs{
-    public generate_card : boolean = false;
-    public generate_typology: boolean = false;
-    public generate_summary: boolean = false;
-    public prompts = {
-        typology_prompt: '',
-        card_gen_prompt: '',
-        summary_prompt: ''
-    }
-
-    constructor(generate_card: boolean,generate_typology: boolean, generate_summary: boolean, prompts = {
-        typology_prompt: '',
-        card_gen_prompt: '',
-        summary_prompt: ''
-    }){
-        this.generate_card = generate_card;
-        this.generate_typology = generate_typology;
-        this.generate_summary = generate_summary;
-        this.prompts = prompts
-    }
-
-    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;
-        
-        
-    }
-
+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,21 @@
-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 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,
+
+
+    }
 }

package/tsconfig.json

@@ -1,12 +1,12 @@
-{
-  "compilerOptions": {
-    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
-    "module": "commonjs" /* Specify what module code is generated. */,
-    "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,
-    "rootDir": "./src",
-    "outDir": "./dist" /* Enable all strict type-checking options. */
-  },
-  "exclude": ["./src/*/*.d.ts"]
-}
+{
+  "compilerOptions": {
+    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    "module": "commonjs" /* Specify what module code is generated. */,
+    "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,
+    "rootDir": "./src",
+    "outDir": "./dist" /* Enable all strict type-checking options. */
+  },
+  "exclude": ["./src/*/*.d.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;