@grnsft/if 0.0.2

package/build/__mocks__/model-universe/index.d.ts

@@ -0,0 +1,33 @@
+import { IOutputModelInterface } from '../../lib';
+import { ImplInitializeModel, InitalizedModels } from '../../types/models-universe';
+export declare class MockModel implements IOutputModelInterface {
+    modelIdentifier(): string;
+    configure(): Promise<IOutputModelInterface>;
+    execute(): Promise<any[]>;
+    authenticate(): void;
+}
+/**
+ * Models Initialization Lifecycle.
+ */
+export declare class ModelsUniverse {
+    /**
+     * Models list.
+     */
+    initalizedModels: InitalizedModels;
+    /**
+     * Gets model class by provided `name` param.
+     */
+    private handBuiltinModel;
+    /**
+     * Gets model based on `name` and `kind` params.
+     */
+    private handModelByCriteria;
+    /**
+     * Initializes and registers model.
+     */
+    writeDown(model: ImplInitializeModel): InitalizedModels;
+    /**
+     * Returns existing model by `name`.
+     */
+    getInitializedModel(modelName: string, config: any): Promise<IOutputModelInterface>;
+}

package/build/__mocks__/model-universe/index.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelsUniverse = exports.MockModel = void 0;
+const config_1 = require("../../config");
+const { NOT_INITIALIZED_MODEL } = config_1.STRINGS;
+class MockModel {
+    modelIdentifier() {
+        return 'mock';
+    }
+    configure() {
+        return Promise.resolve(this);
+    }
+    execute() {
+        return Promise.resolve([{ data: 'mock-data' }]);
+    }
+    authenticate() { }
+}
+exports.MockModel = MockModel;
+/**
+ * Models Initialization Lifecycle.
+ */
+class ModelsUniverse {
+    constructor() {
+        /**
+         * Models list.
+         */
+        this.initalizedModels = {};
+    }
+    /**
+     * Gets model class by provided `name` param.
+     */
+    handBuiltinModel() {
+        return MockModel;
+    }
+    /**
+     * Gets model based on `name` and `kind` params.
+     */
+    handModelByCriteria() {
+        return this.handBuiltinModel();
+    }
+    /**
+     * Initializes and registers model.
+     */
+    writeDown(model) {
+        const { name } = model;
+        const Model = this.handModelByCriteria();
+        const callback = async () => {
+            const initalizedModel = await new Model().configure();
+            return initalizedModel;
+        };
+        this.initalizedModels = {
+            ...this.initalizedModels,
+            [name]: callback,
+        };
+        return this.initalizedModels;
+    }
+    /**
+     * Returns existing model by `name`.
+     */
+    async getInitializedModel(modelName, config) {
+        if (this.initalizedModels[modelName]) {
+            return await this.initalizedModels[modelName](config);
+        }
+        throw new Error(NOT_INITIALIZED_MODEL(modelName));
+    }
+}
+exports.ModelsUniverse = ModelsUniverse;
+//# sourceMappingURL=data:application/json;base64,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

package/build/__mocks__/watt-time/data.json

@@ -0,0 +1,119 @@
+[
+    {
+        "point_time": "2021-01-01T01:00:00.000Z",
+        "value": 942,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    },
+    {
+        "point_time": "2021-01-01T00:55:00.000Z",
+        "value": 931,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    },
+    {
+        "point_time": "2021-01-01T00:50:00.000Z",
+        "value": 930,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    },
+    {
+        "point_time": "2021-01-01T00:45:00.000Z",
+        "value": 930,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    },
+    {
+        "point_time": "2021-01-01T00:40:00.000Z",
+        "value": 927,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    },
+    {
+        "point_time": "2021-01-01T00:35:00.000Z",
+        "value": 934,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    },
+    {
+        "point_time": "2021-01-01T00:30:00.000Z",
+        "value": 933,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    },
+    {
+        "point_time": "2021-01-01T00:25:00.000Z",
+        "value": 934,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    },
+    {
+        "point_time": "2021-01-01T00:20:00.000Z",
+        "value": 935,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    },
+    {
+        "point_time": "2021-01-01T00:15:00.000Z",
+        "value": 986,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    },
+    {
+        "point_time": "2021-01-01T00:10:00.000Z",
+        "value": 989,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    },
+    {
+        "point_time": "2021-01-01T00:05:00.000Z",
+        "value": 993,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    },
+    {
+        "point_time": "2021-01-01T00:00:00.000Z",
+        "value": 997,
+        "frequency": 300,
+        "market": "RTM",
+        "ba": "CAISO_NORTH",
+        "datatype": "MOER",
+        "version": "3.2"
+    }
+]

package/build/__tests__/integration/ompl/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/integration/ompl/index.test.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const globals_1 = require("@jest/globals");
+const yaml_1 = require("../../../util/yaml");
+const node_test_1 = require("node:test");
+globals_1.jest.setTimeout(30000);
+(0, node_test_1.describe)('ompls: ', () => {
+    const path = 'examples/ompls';
+    const files = fs.readdirSync(path);
+    /*
+     * If there are no files in examples/ompls, prompt user to run ompl-test bash script
+     */
+    if (files.length === 0) {
+        throw 'no ompl files available. Please run scripts/impact-test.sh before running these tests.';
+    }
+    (0, node_test_1.describe)('computing(): ', () => {
+        /*
+         * For each file in examples/ompls, load it and run test
+         */
+        files.forEach(file => {
+            if (file.includes('nesting')) {
+                (0, globals_1.it)('check nested ompls have outputs field', async () => {
+                    globals_1.expect.assertions(2);
+                    const ompl = await (0, yaml_1.openYamlFileAsObject)(path + '/' + file);
+                    const expectedProperty = 'outputs';
+                    (0, globals_1.expect)(ompl['graph']['children']['child']['children']['child-1']).toHaveProperty(expectedProperty);
+                    (0, globals_1.expect)(ompl['graph']['children']['child']['children']['child-2']).toHaveProperty(expectedProperty);
+                });
+            }
+            else {
+                (0, globals_1.it)('check ompls have outputs field', async () => {
+                    globals_1.expect.assertions(1);
+                    const ompl = await (0, yaml_1.openYamlFileAsObject)(path + '/' + file);
+                    const expectedProperty = 'outputs';
+                    (0, globals_1.expect)(ompl['graph']['children']['child']).toHaveProperty(expectedProperty);
+                });
+            }
+            if (file.includes('sci-m')) {
+                (0, globals_1.it)('checks `sci-m` ompl to have outputs property.', async () => {
+                    const ompl = await (0, yaml_1.openYamlFileAsObject)(`${path}/${file}`);
+                    const outputData = JSON.stringify(ompl['graph']['children']['child']['outputs']);
+                    const response = outputData.includes('m');
+                    (0, globals_1.expect)(response).toBeTruthy();
+                });
+            }
+            if (file.includes('complex-pipeline')) {
+                (0, globals_1.it)('checks `complex-pipeline` to have `energy-memory`, `energy-cpu`, etc. properties in output.', async () => {
+                    const ompl = await (0, yaml_1.openYamlFileAsObject)(`${path}/${file}`);
+                    const res = JSON.stringify(ompl['graph']['children']['child']['outputs'][0]);
+                    (0, globals_1.expect)(res.includes('energy-memory') &&
+                        res.includes('energy-cpu') &&
+                        res.includes('energy-network') &&
+                        res.includes('energy') &&
+                        res.includes('operational-carbon')).toBeTruthy();
+                });
+            }
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/__tests__/unit/lib/azure-importer/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/__tests__/unit/lib/azure-importer/index.test.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const azure_1 = require("../../../../__mocks__/azure");
+jest.mock('@azure/identity', () => ({
+    __esModule: true,
+    DefaultAzureCredential: azure_1.MockAzureCredentials,
+}));
+jest.mock('@azure/arm-monitor', () => ({
+    __esModule: true,
+    MonitorClient: azure_1.MockMonitorClient,
+}));
+jest.mock('@azure/arm-compute', () => ({
+    __esModule: true,
+    ComputeManagementClient: azure_1.MockComputeManagementClient,
+}));
+const azure_importer_1 = require("../../../../lib/azure-importer");
+jest.setTimeout(30000);
+describe('lib/azure-importer: ', () => {
+    describe('init AzureImporterModel: ', () => {
+        it('initalizes object with properties.', async () => {
+            const azureModel = await new azure_importer_1.AzureImporterModel();
+            expect(azureModel).toHaveProperty('authenticate');
+            expect(azureModel).toHaveProperty('configure');
+            expect(azureModel).toHaveProperty('execute');
+        });
+    });
+    describe('configure(): ', () => {
+        it('configures model instance with given params.', async () => {
+            const name = 'mock-name';
+            const params = {};
+            const model = await new azure_importer_1.AzureImporterModel().configure(name, params);
+            expect(model).toBeInstanceOf(azure_importer_1.AzureImporterModel);
+        });
+    });
+    describe('authenticate(): ', () => {
+        it('authenticate is undefined', async () => {
+            const azureModel = await new azure_importer_1.AzureImporterModel().configure('name', {});
+            expect(azureModel).toBeInstanceOf(azure_importer_1.AzureImporterModel);
+            await expect(azureModel.authenticate({})).toBe(undefined);
+        });
+    });
+    describe('configure(): ', () => {
+        it('configure returns name and empty config', async () => {
+            const azureModel = new azure_importer_1.AzureImporterModel();
+            await expect(azureModel.configure('azure', {})).resolves.toBeInstanceOf(azure_importer_1.AzureImporterModel);
+            expect(azureModel.name).toBe('azure');
+            expect(azureModel.staticParams).toStrictEqual({});
+        });
+    });
+    describe('modelIdentifier(): ', () => {
+        it('modelIdendifier() returns expected name', async () => {
+            const azureModel = new azure_importer_1.AzureImporterModel();
+            expect(azureModel.modelIdentifier()).toBe('azure');
+        });
+    });
+    describe('execute(): ', () => {
+        it('throws error for missing input field.', async () => {
+            const azureModel = new azure_importer_1.AzureImporterModel();
+            expect.assertions(2);
+            expect(await azureModel.configure('azure', {})).toBeInstanceOf(azure_importer_1.AzureImporterModel);
+            try {
+                await azureModel.execute([
+                    {
+                        timestamp: '2023-11-02T10:35:31.820Z',
+                        duration: 3600,
+                        'azure-observation-aggregation': 'average',
+                        'azure-subscription-id': '9de7e19f-8a18-4e73-9451-45fc74e7d0d3',
+                        'azure-resource-group': 'vm1_group',
+                        'azure-vm-name': 'vm1',
+                    },
+                ]);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    expect(error).toBeInstanceOf(Error);
+                }
+            }
+        });
+        it('throws error if time is provided in seconds.', async () => {
+            const azureModel = new azure_importer_1.AzureImporterModel();
+            expect.assertions(2);
+            try {
+                await azureModel.execute([
+                    {
+                        timestamp: '2023-11-02T10:35:31.820Z',
+                        duration: 3600,
+                        'azure-observation-window': '5 sec',
+                        'azure-observation-aggregation': 'average',
+                        'azure-subscription-id': '9de7e19f-8a18-4e73-9451-45fc74e7d0d3',
+                        'azure-resource-group': 'vm1_group',
+                        'azure-vm-name': 'vm1',
+                    },
+                ]);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    expect(error).toBeInstanceOf(Error);
+                    expect(error.message).toEqual('The minimum unit of time for azure importer is minutes');
+                }
+            }
+        });
+        it('throws error for time unit of seconds ', async () => {
+            const azureModel = new azure_importer_1.AzureImporterModel();
+            await expect(azureModel.execute([
+                {
+                    timestamp: '2023-11-02T10:35:31.820Z',
+                    duration: 3600,
+                    'azure-observation-window': '5 sec',
+                    'azure-observation-aggregation': 'average',
+                    'azure-subscription-id': '9de7e19f-8a18-4e73-9451-45fc74e7d0d3',
+                    'azure-resource-group': 'vm1_group',
+                    'azure-vm-name': 'vm1',
+                },
+            ])).rejects.toStrictEqual(Error('The minimum unit of time for azure importer is minutes'));
+        });
+        it('returns valid data.', async () => {
+            const azureModel = new azure_importer_1.AzureImporterModel();
+            await expect(azureModel.execute([
+                {
+                    timestamp: '2023-11-02T10:35:00.000Z',
+                    duration: 300,
+                    'azure-observation-window': '5 mins',
+                    'azure-observation-aggregation': 'average',
+                    'azure-subscription-id': '9de7e19f-8a18-4e73-9451-45fc74e7d0d3',
+                    'azure-resource-group': 'vm1_group',
+                    'azure-vm-name': 'vm1',
+                    'grid-carbon-intensity': 951,
+                },
+            ])).resolves.toEqual([
+                {
+                    timestamp: '2023-11-02T10:35:00.000Z',
+                    duration: 300,
+                    'grid-carbon-intensity': 951,
+                    'azure-observation-aggregation': 'average',
+                    'azure-observation-window': '5 mins',
+                    'azure-resource-group': 'vm1_group',
+                    'azure-subscription-id': '9de7e19f-8a18-4e73-9451-45fc74e7d0d3',
+                    'azure-vm-name': 'vm1',
+                    'cpu-util': '3.14',
+                    'mem-availableGB': 0.5,
+                    'mem-usedGB': 0.5,
+                    'total-memoryGB': 1,
+                    'mem-util': 50,
+                    location: 'uksouth',
+                    'cloud-instance-type': 'Standard_B1s',
+                    'cloud-vendor': 'azure',
+                },
+            ]);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.test.js","sourceRoot":"","sources":["../../../../../src/__tests__/unit/lib/azure-importer/index.test.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  MockAzureCredentials,\n  MockMonitorClient,\n  MockComputeManagementClient,\n} from '../../../../__mocks__/azure';\n\njest.mock('@azure/identity', () => ({\n  __esModule: true,\n  DefaultAzureCredential: MockAzureCredentials,\n}));\n\njest.mock('@azure/arm-monitor', () => ({\n  __esModule: true,\n  MonitorClient: MockMonitorClient,\n}));\n\njest.mock('@azure/arm-compute', () => ({\n  __esModule: true,\n  ComputeManagementClient: MockComputeManagementClient,\n}));\n\nimport {AzureImporterModel} from '../../../../lib/azure-importer';\n\njest.setTimeout(30000);\n\ndescribe('lib/azure-importer: ', () => {\n  describe('init AzureImporterModel: ', () => {\n    it('initalizes object with properties.', async () => {\n      const azureModel = await new AzureImporterModel();\n      expect(azureModel).toHaveProperty('authenticate');\n      expect(azureModel).toHaveProperty('configure');\n      expect(azureModel).toHaveProperty('execute');\n    });\n  });\n\n  describe('configure(): ', () => {\n    it('configures model instance with given params.', async () => {\n      const name = 'mock-name';\n      const params = {};\n      const model = await new AzureImporterModel().configure(name, params);\n\n      expect(model).toBeInstanceOf(AzureImporterModel);\n    });\n  });\n\n  describe('authenticate(): ', () => {\n    it('authenticate is undefined', async () => {\n      const azureModel = await new AzureImporterModel().configure('name', {});\n      expect(azureModel).toBeInstanceOf(AzureImporterModel);\n      await expect(azureModel.authenticate({})).toBe(undefined);\n    });\n  });\n\n  describe('configure(): ', () => {\n    it('configure returns name and empty config', async () => {\n      const azureModel = new AzureImporterModel();\n      await expect(azureModel.configure('azure', {})).resolves.toBeInstanceOf(\n        AzureImporterModel\n      );\n      expect(azureModel.name).toBe('azure');\n      expect(azureModel.staticParams).toStrictEqual({});\n    });\n  });\n\n  describe('modelIdentifier(): ', () => {\n    it('modelIdendifier() returns expected name', async () => {\n      const azureModel = new AzureImporterModel();\n      expect(azureModel.modelIdentifier()).toBe('azure');\n    });\n  });\n\n  describe('execute(): ', () => {\n    it('throws error for missing input field.', async () => {\n      const azureModel = new AzureImporterModel();\n      expect.assertions(2);\n      expect(await azureModel.configure('azure', {})).toBeInstanceOf(\n        AzureImporterModel\n      );\n      try {\n        await azureModel.execute([\n          {\n            timestamp: '2023-11-02T10:35:31.820Z',\n            duration: 3600,\n            'azure-observation-aggregation': 'average',\n            'azure-subscription-id': '9de7e19f-8a18-4e73-9451-45fc74e7d0d3',\n            'azure-resource-group': 'vm1_group',\n            'azure-vm-name': 'vm1',\n          },\n        ]);\n      } catch (error) {\n        if (error instanceof Error) {\n          expect(error).toBeInstanceOf(Error);\n        }\n      }\n    });\n\n    it('throws error if time is provided in seconds.', async () => {\n      const azureModel = new AzureImporterModel();\n\n      expect.assertions(2);\n\n      try {\n        await azureModel.execute([\n          {\n            timestamp: '2023-11-02T10:35:31.820Z',\n            duration: 3600,\n            'azure-observation-window': '5 sec',\n            'azure-observation-aggregation': 'average',\n            'azure-subscription-id': '9de7e19f-8a18-4e73-9451-45fc74e7d0d3',\n            'azure-resource-group': 'vm1_group',\n            'azure-vm-name': 'vm1',\n          },\n        ]);\n      } catch (error) {\n        if (error instanceof Error) {\n          expect(error).toBeInstanceOf(Error);\n          expect(error.message).toEqual(\n            'The minimum unit of time for azure importer is minutes'\n          );\n        }\n      }\n    });\n\n    it('throws error for time unit of seconds ', async () => {\n      const azureModel = new AzureImporterModel();\n      await expect(\n        azureModel.execute([\n          {\n            timestamp: '2023-11-02T10:35:31.820Z',\n            duration: 3600,\n            'azure-observation-window': '5 sec',\n            'azure-observation-aggregation': 'average',\n            'azure-subscription-id': '9de7e19f-8a18-4e73-9451-45fc74e7d0d3',\n            'azure-resource-group': 'vm1_group',\n            'azure-vm-name': 'vm1',\n          },\n        ])\n      ).rejects.toStrictEqual(\n        Error('The minimum unit of time for azure importer is minutes')\n      );\n    });\n\n    it('returns valid data.', async () => {\n      const azureModel = new AzureImporterModel();\n      await expect(\n        azureModel.execute([\n          {\n            timestamp: '2023-11-02T10:35:00.000Z',\n            duration: 300,\n            'azure-observation-window': '5 mins',\n            'azure-observation-aggregation': 'average',\n            'azure-subscription-id': '9de7e19f-8a18-4e73-9451-45fc74e7d0d3',\n            'azure-resource-group': 'vm1_group',\n            'azure-vm-name': 'vm1',\n            'grid-carbon-intensity': 951,\n          },\n        ])\n      ).resolves.toEqual([\n        {\n          timestamp: '2023-11-02T10:35:00.000Z',\n          duration: 300,\n          'grid-carbon-intensity': 951,\n          'azure-observation-aggregation': 'average',\n          'azure-observation-window': '5 mins',\n          'azure-resource-group': 'vm1_group',\n          'azure-subscription-id': '9de7e19f-8a18-4e73-9451-45fc74e7d0d3',\n          'azure-vm-name': 'vm1',\n          'cpu-util': '3.14',\n          'mem-availableGB': 0.5,\n          'mem-usedGB': 0.5,\n          'total-memoryGB': 1,\n          'mem-util': 50,\n          location: 'uksouth',\n          'cloud-instance-type': 'Standard_B1s',\n          'cloud-vendor': 'azure',\n        },\n      ]);\n    });\n  });\n});\n"]}

package/build/__tests__/unit/lib/boavizta/index.test.d.ts

@@ -0,0 +1 @@
+export {};