only_ever_generator 0.0.9 → 1.0.1

package/dist/index.js

@@ -1,18 +1,23 @@
 "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.OnlyEverGenerator = void 0;
-// import express from "express";
-// import { returnCardGenPrompt } from "./constants/prompts/card_gen_prompt";
-// import { returnTypologyPrompt } from "./constants/prompts/typology_prompt";
-// import { GenerateArgs } from "./utils/generate_args";
-// import { returnFields, returnHeadings, returnSourceData } from "./constants/source_data";
-const app_1 = require("./bootstrap/app");
-Object.defineProperty(exports, "OnlyEverGenerator", { enumerable: true, get: function () { return app_1.OnlyEverGenerator; } });
-/// All the Codes Below uses express and are strictly for development purpose, while publishing the package, comment everything
-/// below this line
-// let oeGen =  new OnlyEverGenerator(config.openAIKey,"gpt-3.5-turbo-1106" ,returnSourceData(),returnFields())
+exports.GenerateArgs = exports.OnlyEverGenerator = void 0;
+const parse_source_content_1 = require("./class/parse/parse_source_content");
+const open_ai_service_1 = require("./class/services/open_ai_service");
+// const app = express();
+// const port = 3000;
+// let openAiService = new OpenAiService(config.openAIKey);
+// let oeGen =  new OnlyEverGenerator(config.openAIKey, returnSourceData())
 // app.get('/', async (req, res)  => {
-//     let data = oeGen._returnParsedContent();
+//     let data = oeGen.returnParsedContent();
 //     // let parsedData = parseResponse()
 //     res.send(data);
 // });
@@ -40,8 +45,7 @@ Object.defineProperty(exports, "OnlyEverGenerator", { enumerable: true, get: fun
 //       }
 //     )
 //     let typologyRequest = await oeGen.generate(
-//       true,
-//       true
+//       args,
 //     );
 //     res.send(typologyRequest);
 //   }
@@ -49,3 +53,99 @@ Object.defineProperty(exports, "OnlyEverGenerator", { enumerable: true, get: fun
 // app.listen(port, () => {
 //   console.log(`Example app listening at http://localhost:${port}`);
 // });
+class OnlyEverGenerator {
+    constructor(apiKey, model, content) {
+        this.api_key = '';
+        this.parsedContent = '';
+        this.typologyResponse = {};
+        this.cardgenResponse = {};
+        this.summarizeResponse = {};
+        this.api_key = apiKey;
+        this.openAiService = new open_ai_service_1.OpenAiService(apiKey, model !== null && model !== void 0 ? model : 'gpt-3.5-turbo-1106');
+        this.parsedContent = new parse_source_content_1.ParseSourceContent(content).parse();
+    }
+    ;
+    generate(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const responseToReturn = [];
+            const whatNeedsToBeGenerated = args.getWhatNeedsToBeGenerated();
+            for (let elem of whatNeedsToBeGenerated)
+                if (elem == 'generate_tyopology') {
+                    this.typologyResponse = yield this.generateTypology((_a = args.prompts.typology_prompt) !== null && _a !== void 0 ? _a : '', this.parsedContent);
+                    responseToReturn.push(this.typologyResponse);
+                }
+                else if (elem == 'generate_card') {
+                    this.cardgenResponse = yield this.generateCard((_b = args.prompts.card_gen_prompt) !== null && _b !== void 0 ? _b : '', this.parsedContent + JSON.stringify(this.typologyResponse));
+                    responseToReturn.push(this.cardgenResponse);
+                }
+                else if (elem == 'generate_summary') {
+                    this.summarizeResponse = yield this.generateSummary((_c = args.prompts.summary_prompt) !== null && _c !== void 0 ? _c : '', this.parsedContent);
+                    responseToReturn.push(this.summarizeResponse);
+                }
+            return responseToReturn;
+        });
+    }
+    _returnParsedContent() {
+        return this.parsedContent;
+    }
+    generateCard(prompt, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let response = yield ((_a = this.openAiService) === null || _a === void 0 ? void 0 : _a.sendRequest(prompt, this.parsedContent));
+            response['type'] = 'card_gen';
+            return response;
+        });
+    }
+    generateTypology(prompt, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let response = yield ((_a = this.openAiService) === null || _a === void 0 ? void 0 : _a.sendRequest(prompt, this.parsedContent));
+            response['type'] = 'typology';
+            return response;
+        });
+    }
+    generateSummary(prompt, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let response = yield ((_a = this.openAiService) === null || _a === void 0 ? void 0 : _a.sendRequest(prompt, this.parsedContent));
+            response['type'] = 'summary';
+            return response;
+        });
+    }
+}
+exports.OnlyEverGenerator = OnlyEverGenerator;
+class GenerateArgs {
+    constructor(generate_card, generate_typology, generate_summary, prompts = {
+        typology_prompt: '',
+        card_gen_prompt: '',
+        summary_prompt: ''
+    }) {
+        this.generate_card = false;
+        this.generate_typology = false;
+        this.generate_summary = false;
+        this.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;
+    }
+}
+exports.GenerateArgs = GenerateArgs;

package/dist/service/open_ai_request.js

@@ -43,6 +43,7 @@ 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/typology_gen/generate_typology.js

@@ -9,64 +9,19 @@ 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, 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, _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": (_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);
-            }
-            else {
-                return response;
-            }
-        });
-    }
-    parseTypologyOnSuccess(responseData) {
-        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) {
-        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';
-            return {
-                status_code: responseData.status_code,
-                metadata: responseData.metadata,
-            };
-        });
-    }
+exports.generateTypology = void 0;
+// import { openAIRequest } from "../service/open_ai_request.js";
+function generateTypology(openAiService, prompt, message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // let openAiService = new OpenAiService(config.openAIKey)
+            let response = yield openAiService.sendRequest(prompt, message);
+            // let response = returnTypologyData();
+            return response;
+        }
+        catch (e) {
+            throw e;
+        }
+    });
 }
-exports.GenerateTypology = GenerateTypology;
+exports.generateTypology = generateTypology;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "only_ever_generator",
-  "version": "0.0.9",
+  "version": "1.0.1",
   "main": "dist/index.js",
   "scripts": {
     "start": "nodemon dist/index.js",
@@ -10,6 +10,7 @@
   "keywords": [],
   "author": "shree",
   "license": "ISC",
+
   "devDependencies": {
     "@types/express": "^4.17.21",
     "@types/node": "^20.14.2",
@@ -18,14 +19,6 @@
     "typescript": "^5.4.5"
   },
   "dependencies": {
-    "axios": "^1.7.2",
-    "dotenv": "^16.4.5",
-    "express": "^4.19.2"
-  },
-  "eslintConfig": {
-    "parser": "typescript-eslint-parser",
-    "plugins": [
-      "typescript"
-    ]
+    "axios": "^1.7.2"
   }
 }

package/readme.md

@@ -8,16 +8,25 @@ The class [OnlyEverGenerator] is the Entry point for the generation module it ha
 
 The [OnlyEverGenerator] currently exposes a main method, [generate] which handles all types of generation and takes a Param 
 ```
-generate(generate_typology = false,generate_card = false) method takes two args, generate_typology and generate_cards, which are both boolean.
+GenerateArgs : 
 For Eg: 
 let oeGenerator = new OnlyEverGenerator(
     api_key,
     model,
     [Block1,Block2,Block3], // oe content model
 );
- 
+    let args = new GenerateArgs(
+       true,
+       true,
+       false,
+        {
+         typology_prompt: typologyPrompt, 
+         card_gen_prompt: cardPrompt,
+         summary_prompt: summary prompt,
+       }
+    )
 
-let responsesArray = await oeGenerator.generate(true,true);
+let responsesArray = await oeGenerator.generate(args);
 
 
 ```

package/src/bootstrap/app.ts

@@ -1,88 +1,107 @@
-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";
-
-
-/// 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 = {};
+// import { ParseSourceContent } from "../class/parse/parse_source_content";
+// import { OpenAiService } from "../class/services/open_ai_service";
+
+
+
+// export class OnlyEverGenerator{
+//     public api_key: string = '';
+//     public openAiService: OpenAiService | undefined;
+//     parsedContent: String = '';
+//     constructor(apiKey:string, content: Array<any>){
+//         this.api_key = apiKey;
+//         this.openAiService = new OpenAiService(apiKey);
+//         this.parsedContent = new ParseSourceContent(content).parse();
+//     };
+
+//     typologyResponse = {};
+//     cardgenResponse = {};
+//     summarizeResponse = {};
 
     
     
 
-    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);
-        }
-
-        return responseToReturn;
+//     async generate( 
+//         args: GenerateArgs
+//     ): Promise<Array<any>> {
+//         const responseToReturn = [];
+//         const whatNeedsToBeGenerated = args.getWhatNeedsToBeGenerated();
+//         for(let elem of whatNeedsToBeGenerated)
+//         if(elem == 'generate_tyopology'){
+//             this.typologyResponse = await this.generateTypology(args.prompts.typology_prompt ?? '', this.parsedContent);
+//             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);
+//         }else if(elem == 'generate_summary'){
+//             this.summarizeResponse = await this.generateSummary(args.prompts.summary_prompt ?? '', this.parsedContent);
+//             responseToReturn.push(this.summarizeResponse);
+//         }
+
+//         return responseToReturn;
         
-    }
+//     }
     
-    _returnParsedContent(){
-        return this.parsedContent;
-    }
-
-
-    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,
-            this.expectedFields,
-        ).generate();
-        return response;
-    }
+//     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 generateTypology(prompt:String,content:String){
+//         let response =  await this.openAiService?.sendRequest(prompt,this.parsedContent);
+//         response['type'] = 'typology';
+//         return response;
+//     }
+
+//     async generateSummary(prompt:String,content:String){
+//         let response = await this.openAiService?.sendRequest(prompt,this.parsedContent);
+//         response['type']= 'summary';
+//         return response;
+//     }
     
-}
+// }
+
+// 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;
+        
+        
+//     }
+
+// }

package/src/class/services/open_ai_service.ts

@@ -0,0 +1,18 @@
+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);
+    } 
+}
+