only_ever_generator 0.9.5 → 0.9.7

package/dist/typology_gen/generate_typology.js

@@ -0,0 +1,103 @@
+"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.GenerateTypology = void 0;
+const logger_1 = require("../logger");
+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, _d, _e;
+            try {
+                const response = yield ((_a = this.openAiService) === null || _a === void 0 ? void 0 : _a.sendRequest(this.prompt, this.content));
+                response["request_type"] = {
+                    type: "breadth",
+                    n: 1,
+                };
+                response.metadata = {
+                    req_time: (_b = response.generated_at) !== null && _b !== void 0 ? _b : new Date(),
+                    req_type: {
+                        type: "breadth",
+                        n: 1,
+                    },
+                    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);
+                }
+                else {
+                    response.metadata.err_message = response.message;
+                    return response;
+                }
+            }
+            catch (e) {
+                yield new logger_1.ErrorLogger({
+                    type: "typology_parsing",
+                    data: e.message,
+                }).log();
+            }
+        });
+    }
+    parseTypologyOnSuccess(responseData) {
+        responseData.metadata.status = "completed";
+        const generatedContent = responseData.generated_content;
+        const concepts = generatedContent.concepts.map((e) => {
+            return {
+                text: e.concept_text,
+                type: "concept",
+                reference: e.reference,
+            };
+        });
+        const facts = generatedContent.facts.map((e) => {
+            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) {
+        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 = GenerateTypology;

package/dist/utils/generate_args.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateArgs = void 0;
+class GenerateArgs {
+    constructor(generate_card, generate_typology, generate_summary) {
+        this.generate_card = false;
+        this.generate_typology = false;
+        this.generate_summary = false;
+        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;
+    }
+}
+exports.GenerateArgs = GenerateArgs;

package/dist/utils/parse_openai_response.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOpenAiSuccessResponse = parseOpenAiSuccessResponse;
+exports.parseOpenAiFailureResponse = parseOpenAiFailureResponse;
+function parseOpenAiSuccessResponse(responseData) {
+    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),
+    };
+}
+function parseOpenAiFailureResponse(errorResponse) {
+    var _a, _b;
+    // 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,
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "only_ever_generator",
-  "version": "0.9.5",
-  "main": "src/index.ts",
+  "version": "0.9.7",
+  "main": "dist/index.js",
   "scripts": {
     "start": "npm run build && nodemon dist/index.js",
     "build": "tsc",