@grnsft/if 0.2.1 → 0.3.1

package/build/builtins/export-yaml.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportYaml = void 0;
+const yaml_1 = require("../util/yaml");
+const errors_1 = require("../util/errors");
+const { CliInputError } = errors_1.ERRORS;
+const ExportYaml = () => {
+    /** Takes string before hashtag. */
+    const stripHashtag = (path) => path.split('#')[0];
+    /**
+     * Saves output file in YAML format.
+     */
+    const execute = async (tree, context, outputPath) => {
+        if (!outputPath) {
+            throw new CliInputError('Output path is required.');
+        }
+        const outputFile = {
+            ...context,
+            tree,
+        };
+        const path = stripHashtag(outputPath);
+        await (0, yaml_1.saveYamlFileAs)(outputFile, `${path}.yaml`);
+    };
+    return { execute };
+};
+exports.ExportYaml = ExportYaml;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhwb3J0LXlhbWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYnVpbHRpbnMvZXhwb3J0LXlhbWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsdUNBQTRDO0FBRTVDLDJDQUFzQztBQUl0QyxNQUFNLEVBQUMsYUFBYSxFQUFDLEdBQUcsZUFBTSxDQUFDO0FBRXhCLE1BQU0sVUFBVSxHQUFHLEdBQUcsRUFBRTtJQUM3QixtQ0FBbUM7SUFDbkMsTUFBTSxZQUFZLEdBQUcsQ0FBQyxJQUFZLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFFMUQ7O09BRUc7SUFDSCxNQUFNLE9BQU8sR0FBRyxLQUFLLEVBQUUsSUFBUyxFQUFFLE9BQWdCLEVBQUUsVUFBa0IsRUFBRSxFQUFFO1FBQ3hFLElBQUksQ0FBQyxVQUFVLEVBQUU7WUFDZixNQUFNLElBQUksYUFBYSxDQUFDLDBCQUEwQixDQUFDLENBQUM7U0FDckQ7UUFFRCxNQUFNLFVBQVUsR0FBRztZQUNqQixHQUFHLE9BQU87WUFDVixJQUFJO1NBQ0wsQ0FBQztRQUNGLE1BQU0sSUFBSSxHQUFHLFlBQVksQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUV0QyxNQUFNLElBQUEscUJBQWMsRUFBQyxVQUFVLEVBQUUsR0FBRyxJQUFJLE9BQU8sQ0FBQyxDQUFDO0lBQ25ELENBQUMsQ0FBQztJQUVGLE9BQU8sRUFBQyxPQUFPLEVBQUMsQ0FBQztBQUNuQixDQUFDLENBQUM7QUF0QlcsUUFBQSxVQUFVLGNBc0JyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7c2F2ZVlhbWxGaWxlQXN9IGZyb20gJy4uL3V0aWwveWFtbCc7XG5cbmltcG9ydCB7RVJST1JTfSBmcm9tICcuLi91dGlsL2Vycm9ycyc7XG5cbmltcG9ydCB7Q29udGV4dH0gZnJvbSAnLi4vdHlwZXMvbWFuaWZlc3QnO1xuXG5jb25zdCB7Q2xpSW5wdXRFcnJvcn0gPSBFUlJPUlM7XG5cbmV4cG9ydCBjb25zdCBFeHBvcnRZYW1sID0gKCkgPT4ge1xuICAvKiogVGFrZXMgc3RyaW5nIGJlZm9yZSBoYXNodGFnLiAqL1xuICBjb25zdCBzdHJpcEhhc2h0YWcgPSAocGF0aDogc3RyaW5nKSA9PiBwYXRoLnNwbGl0KCcjJylbMF07XG5cbiAgLyoqXG4gICAqIFNhdmVzIG91dHB1dCBmaWxlIGluIFlBTUwgZm9ybWF0LlxuICAgKi9cbiAgY29uc3QgZXhlY3V0ZSA9IGFzeW5jICh0cmVlOiBhbnksIGNvbnRleHQ6IENvbnRleHQsIG91dHB1dFBhdGg6IHN0cmluZykgPT4ge1xuICAgIGlmICghb3V0cHV0UGF0aCkge1xuICAgICAgdGhyb3cgbmV3IENsaUlucHV0RXJyb3IoJ091dHB1dCBwYXRoIGlzIHJlcXVpcmVkLicpO1xuICAgIH1cblxuICAgIGNvbnN0IG91dHB1dEZpbGUgPSB7XG4gICAgICAuLi5jb250ZXh0LFxuICAgICAgdHJlZSxcbiAgICB9O1xuICAgIGNvbnN0IHBhdGggPSBzdHJpcEhhc2h0YWcob3V0cHV0UGF0aCk7XG5cbiAgICBhd2FpdCBzYXZlWWFtbEZpbGVBcyhvdXRwdXRGaWxlLCBgJHtwYXRofS55YW1sYCk7XG4gIH07XG5cbiAgcmV0dXJuIHtleGVjdXRlfTtcbn07XG4iXX0=

package/build/builtins/group-by.d.ts

@@ -0,0 +1,5 @@
+import { GroupByPlugin } from '../types/interface';
+/**
+ * Plugin for inputs grouping.
+ */
+export declare const GroupBy: () => GroupByPlugin;

package/build/builtins/group-by.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupBy = void 0;
+const errors_1 = require("../util/errors");
+const config_1 = require("../config");
+const { InvalidGrouping } = errors_1.ERRORS;
+const { INVALID_GROUP_BY } = config_1.STRINGS;
+/**
+ * Plugin for inputs grouping.
+ */
+const GroupBy = () => {
+    const metadata = {
+        kind: 'groupby',
+    };
+    /**
+     * Creates structure to insert inputs by groups.
+     */
+    const appendGroup = (value, object, groups) => {
+        if (groups.length > 0) {
+            const group = groups.shift();
+            object.children = object.children ?? {};
+            object.children[group] = object.children[group] ?? {};
+            if (groups.length === 0) {
+                if (object.children[group].inputs &&
+                    object.children[group].inputs.length > 0) {
+                    object.children[group].inputs.push(value);
+                }
+                else {
+                    object.children[group].inputs = [value];
+                }
+            }
+            appendGroup(value, object.children[group], groups);
+        }
+        return object;
+    };
+    /**
+     * Interates over inputs, grabs config-group types values for each one.
+     * Based on grouping types, initializes the structure grouped structure.
+     */
+    const execute = (inputs, config) => inputs.reduce((acc, input) => {
+        const groups = config.group.map(groupType => {
+            if (!input[groupType]) {
+                throw new InvalidGrouping(INVALID_GROUP_BY(groupType));
+            }
+            return input[groupType];
+        });
+        acc = {
+            ...acc,
+            ...appendGroup(input, acc, groups),
+        };
+        return acc;
+    }, {}).children;
+    return { metadata, execute };
+};
+exports.GroupBy = GroupBy;
+//# sourceMappingURL=data:application/json;base64,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

package/build/{models → builtins}/index.js

@@ -5,4 +5,4 @@ var group_by_1 = require("./group-by");
 Object.defineProperty(exports, "GroupBy", { enumerable: true, get: function () { return group_by_1.GroupBy; } });
 var time_sync_1 = require("./time-sync");
 Object.defineProperty(exports, "TimeSync", { enumerable: true, get: function () { return time_sync_1.TimeSync; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbW9kZWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHVDQUFtQztBQUEzQixtR0FBQSxPQUFPLE9BQUE7QUFDZix5Q0FBcUM7QUFBN0IscUdBQUEsUUFBUSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtHcm91cEJ5fSBmcm9tICcuL2dyb3VwLWJ5JztcbmV4cG9ydCB7VGltZVN5bmN9IGZyb20gJy4vdGltZS1zeW5jJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYnVpbHRpbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsdUNBQW1DO0FBQTNCLG1HQUFBLE9BQU8sT0FBQTtBQUNmLHlDQUFxQztBQUE3QixxR0FBQSxRQUFRLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge0dyb3VwQnl9IGZyb20gJy4vZ3JvdXAtYnknO1xuZXhwb3J0IHtUaW1lU3luY30gZnJvbSAnLi90aW1lLXN5bmMnO1xuIl19

package/build/{models → builtins}/time-sync.d.ts

@@ -1,3 +1,3 @@
+import { ExecutePlugin } from '../types/interface';
 import { TimeNormalizerConfig } from '../types/time-sync';
-import { PluginInterface } from '../types/interface';
-export declare const TimeSync: (globalConfig: TimeNormalizerConfig) => PluginInterface;
+export declare const TimeSync: (globalConfig: TimeNormalizerConfig) => ExecutePlugin;

package/build/builtins/time-sync.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeSync = void 0;
+const types_1 = require("node:util/types");
+const luxon_1 = require("luxon");
+const zod_1 = require("zod");
+const parameterize_1 = require("../lib/parameterize");
+const errors_1 = require("../util/errors");
+const config_1 = require("../config");
+const validations_1 = require("../util/validations");
+const { InputValidationError } = errors_1.ERRORS;
+const { INVALID_TIME_NORMALIZATION, INVALID_OBSERVATION_OVERLAP, AVOIDING_PADDING_BY_EDGES, } = config_1.STRINGS;
+const TimeSync = (globalConfig) => {
+    const metadata = {
+        kind: 'execute',
+    };
+    /**
+     * Take input array and return time-synchronized input array.
+     */
+    const execute = (inputs) => {
+        const validatedConfig = validateGlobalConfig();
+        const timeParams = {
+            startTime: luxon_1.DateTime.fromISO(validatedConfig['start-time']),
+            endTime: luxon_1.DateTime.fromISO(validatedConfig['end-time']),
+            interval: validatedConfig.interval,
+            allowPadding: validatedConfig['allow-padding'],
+        };
+        const pad = checkForPadding(inputs, timeParams);
+        validatePadding(pad, timeParams);
+        const paddedInputs = padInputs(inputs, pad, timeParams);
+        const flattenInputs = paddedInputs.reduce((acc, input, index) => {
+            const safeInput = Object.assign({}, input, validateInput(input, index));
+            const currentMoment = parseDate(safeInput.timestamp);
+            /** Checks if not the first input, then check consistency with previous ones. */
+            if (index > 0) {
+                const previousInput = paddedInputs[index - 1];
+                const previousInputTimestamp = parseDate(previousInput.timestamp);
+                /** Checks for timestamps overlap. */
+                if (parseDate(previousInput.timestamp).plus({
+                    seconds: previousInput.duration,
+                }) > currentMoment) {
+                    throw new InputValidationError(INVALID_OBSERVATION_OVERLAP);
+                }
+                const compareableTime = previousInputTimestamp.plus({
+                    seconds: previousInput.duration,
+                });
+                const timelineGapSize = currentMoment
+                    .diff(compareableTime)
+                    .as('seconds');
+                /** Checks if there is gap in timeline. */
+                if (timelineGapSize > 1) {
+                    acc.push(...getZeroishInputPerSecondBetweenRange(compareableTime, currentMoment, safeInput));
+                }
+            }
+            /** Break down current observation. */
+            for (let i = 0; i < safeInput.duration; i++) {
+                const normalizedInput = breakDownInput(safeInput, i);
+                acc.push(normalizedInput);
+            }
+            return trimInputsByGlobalTimeline(acc, timeParams);
+        }, []);
+        const sortedInputs = flattenInputs.sort((a, b) => parseDate(a.timestamp).diff(parseDate(b.timestamp)).as('seconds'));
+        return resampleInputs(sortedInputs, timeParams);
+    };
+    const parseDate = (date) => {
+        if (!date)
+            return luxon_1.DateTime.invalid('Invalid date');
+        // dates are passed to time-sync.ts both in ISO 8601 format
+        // and as a Date object (from the deserialization of a YAML file)
+        // if the YAML parser fails to identify as a date, it passes as a string
+        if ((0, types_1.isDate)(date)) {
+            return luxon_1.DateTime.fromJSDate(date);
+        }
+        if (typeof date === 'string') {
+            return luxon_1.DateTime.fromISO(date);
+        }
+        throw new InputValidationError(`Unexpected date datatype: ${typeof date}: ${date}`);
+    };
+    /**
+     * Validates input parameters.
+     */
+    const validateInput = (input, index) => {
+        const schema = zod_1.z.object({
+            timestamp: zod_1.z
+                .string({
+                required_error: `required in input[${index}]`,
+            })
+                .datetime({
+                message: `invalid datetime in input[${index}]`,
+            })
+                .or(zod_1.z.date()),
+            duration: zod_1.z.number(),
+        });
+        return (0, validations_1.validate)(schema, input);
+    };
+    /**
+     * Validates global config parameters.
+     */
+    const validateGlobalConfig = () => {
+        if (globalConfig === undefined) {
+            throw new InputValidationError(INVALID_TIME_NORMALIZATION);
+        }
+        const schema = zod_1.z
+            .object({
+            'start-time': zod_1.z.string().datetime(),
+            'end-time': zod_1.z.string().datetime(),
+            interval: zod_1.z.number(),
+            'allow-padding': zod_1.z.boolean(),
+        })
+            .refine(data => data['start-time'] < data['end-time'], {
+            message: '`start-time` should be lower than `end-time`',
+        });
+        return (0, validations_1.validate)(schema, globalConfig);
+    };
+    /**
+     * Calculates minimal factor.
+     */
+    const convertPerInterval = (value, duration) => value / duration;
+    /**
+     * Normalize time per given second.
+     */
+    const normalizeTimePerSecond = (currentRoundMoment, i) => {
+        const thisMoment = parseDate(currentRoundMoment).startOf('second');
+        return thisMoment.plus({ seconds: i });
+    };
+    /**
+     * Breaks down input per minimal time unit.
+     */
+    const breakDownInput = (input, i) => {
+        const inputKeys = Object.keys(input);
+        return inputKeys.reduce((acc, key) => {
+            const method = parameterize_1.parameterize.getAggregationMethod(key);
+            if (key === 'timestamp') {
+                const perSecond = normalizeTimePerSecond(input.timestamp, i);
+                acc[key] = perSecond.toUTC().toISO() ?? '';
+                return acc;
+            }
+            /** @todo use user defined resolution later */
+            if (key === 'duration') {
+                acc[key] = 1;
+                return acc;
+            }
+            acc[key] =
+                method === 'sum'
+                    ? convertPerInterval(input[key], input['duration'])
+                    : input[key];
+            return acc;
+        }, {});
+    };
+    /**
+     * Populates object to fill the gaps in observational timeline using zeroish values.
+     */
+    const fillWithZeroishInput = (input, missingTimestamp) => {
+        const metrics = Object.keys(input);
+        return metrics.reduce((acc, metric) => {
+            if (metric === 'timestamp') {
+                acc[metric] = missingTimestamp.startOf('second').toUTC().toISO() ?? '';
+                return acc;
+            }
+            /** @todo later will be changed to user defined interval */
+            if (metric === 'duration') {
+                acc[metric] = 1;
+                return acc;
+            }
+            if (metric === 'time-reserved') {
+                acc[metric] = acc['duration'];
+                return acc;
+            }
+            const method = parameterize_1.parameterize.getAggregationMethod(metric);
+            if (method === 'avg' || method === 'sum') {
+                acc[metric] = 0;
+                return acc;
+            }
+            acc[metric] = input[metric];
+            return acc;
+        }, {});
+    };
+    /**
+     * Checks if `error on padding` is enabled and padding is needed. If so, then throws error.
+     */
+    const validatePadding = (pad, params) => {
+        const { start, end } = pad;
+        const isPaddingNeeded = start || end;
+        if (!params.allowPadding && isPaddingNeeded) {
+            throw new InputValidationError(AVOIDING_PADDING_BY_EDGES(start, end));
+        }
+    };
+    /**
+     * Checks if padding is needed either at start of the timeline or the end and returns status.
+     */
+    const checkForPadding = (inputs, params) => {
+        const startDiffInSeconds = parseDate(inputs[0].timestamp)
+            .diff(params.startTime)
+            .as('seconds');
+        const lastInput = inputs[inputs.length - 1];
+        const endDiffInSeconds = parseDate(lastInput.timestamp)
+            .plus({ second: lastInput.duration })
+            .diff(params.endTime)
+            .as('seconds');
+        return {
+            start: startDiffInSeconds > 0,
+            end: endDiffInSeconds < 0,
+        };
+    };
+    /**
+     * Iterates over given inputs frame, meanwhile checking if aggregation method is `sum`, then calculates it.
+     * For methods is `avg` and `none` calculating average of the frame.
+     */
+    const resampleInputFrame = (inputsInTimeslot) => {
+        return inputsInTimeslot.reduce((acc, input, index, inputs) => {
+            const metrics = Object.keys(input);
+            metrics.forEach(metric => {
+                const method = parameterize_1.parameterize.getAggregationMethod(metric);
+                acc[metric] = acc[metric] ?? 0;
+                if (metric === 'timestamp') {
+                    acc[metric] = inputs[0][metric];
+                    return;
+                }
+                if (method === 'sum') {
+                    acc[metric] += input[metric];
+                    return;
+                }
+                if (method === 'none') {
+                    acc[metric] = input[metric];
+                    return;
+                }
+                /**
+                 * If timeslot contains records more than one, then divide each metric by the timeslot length,
+                 *  so that their sum yields the timeslot average.
+                 */
+                if (inputsInTimeslot.length > 1 &&
+                    index === inputsInTimeslot.length - 1) {
+                    acc[metric] /= inputsInTimeslot.length;
+                    return;
+                }
+                acc[metric] += input[metric];
+            });
+            return acc;
+        }, {});
+    };
+    /**
+     * Takes each array frame with interval length, then aggregating them together as from units.yaml file.
+     */
+    const resampleInputs = (inputs, params) => {
+        return inputs.reduce((acc, _input, index, inputs) => {
+            const frameStart = index * params.interval;
+            const frameEnd = (index + 1) * params.interval;
+            const inputsFrame = inputs.slice(frameStart, frameEnd);
+            const resampledInput = resampleInputFrame(inputsFrame);
+            /** Checks if resampled input is not empty, then includes in result. */
+            if (Object.keys(resampledInput).length > 0) {
+                acc.push(resampledInput);
+            }
+            return acc;
+        }, []);
+    };
+    /**
+     * Pads zeroish inputs from the beginning or at the end of the inputs if needed.
+     */
+    const padInputs = (inputs, pad, params) => {
+        const { start, end } = pad;
+        const paddedFromBeginning = [];
+        if (start) {
+            paddedFromBeginning.push(...getZeroishInputPerSecondBetweenRange(params.startTime, parseDate(inputs[0].timestamp), inputs[0]));
+        }
+        const paddedArray = paddedFromBeginning.concat(inputs);
+        if (end) {
+            const lastInput = inputs[inputs.length - 1];
+            const lastInputEnd = parseDate(lastInput.timestamp).plus({
+                seconds: lastInput.duration,
+            });
+            paddedArray.push(...getZeroishInputPerSecondBetweenRange(lastInputEnd, params.endTime.plus({ seconds: 1 }), lastInput));
+        }
+        return paddedArray;
+    };
+    const getZeroishInputPerSecondBetweenRange = (startDate, endDate, templateInput) => {
+        const array = [];
+        const dateRange = luxon_1.Interval.fromDateTimes(startDate, endDate);
+        for (const interval of dateRange.splitBy({ second: 1 })) {
+            array.push(fillWithZeroishInput(templateInput, 
+            // as far as I can tell, start will never be null
+            // because if we pass an invalid start/endDate to
+            // Interval, we get a zero length array as the range
+            interval.start || luxon_1.DateTime.invalid('not expected - start is null')));
+        }
+        return array;
+    };
+    /*
+     * Checks if input's timestamp is included in global specified period then leaves it, otherwise.
+     */
+    const trimInputsByGlobalTimeline = (inputs, params) => {
+        return inputs.reduce((acc, item) => {
+            const { timestamp } = item;
+            if (parseDate(timestamp) >= params.startTime &&
+                parseDate(timestamp) <= params.endTime) {
+                acc.push(item);
+            }
+            return acc;
+        }, []);
+    };
+    return { metadata, execute };
+};
+exports.TimeSync = TimeSync;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-sync.js","sourceRoot":"","sources":["../../src/builtins/time-sync.ts"],"names":[],"mappings":"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","sourcesContent":["import {isDate} from 'node:util/types';\nimport {DateTime, DateTimeMaybeValid, Interval} from 'luxon';\nimport {z} from 'zod';\n\nimport {parameterize} from '../lib/parameterize';\n\nimport {ERRORS} from '../util/errors';\n\nimport {STRINGS} from '../config';\n\nimport {ExecutePlugin, PluginParams} from '../types/interface';\nimport {\n  PaddingReceipt,\n  TimeNormalizerConfig,\n  TimeParams,\n} from '../types/time-sync';\nimport {validate} from '../util/validations';\n\nconst {InputValidationError} = ERRORS;\n\nconst {\n  INVALID_TIME_NORMALIZATION,\n  INVALID_OBSERVATION_OVERLAP,\n  AVOIDING_PADDING_BY_EDGES,\n} = STRINGS;\n\nexport const TimeSync = (globalConfig: TimeNormalizerConfig): ExecutePlugin => {\n  const metadata = {\n    kind: 'execute',\n  };\n\n  /**\n   * Take input array and return time-synchronized input array.\n   */\n  const execute = (inputs: PluginParams[]): PluginParams[] => {\n    const validatedConfig = validateGlobalConfig();\n    const timeParams = {\n      startTime: DateTime.fromISO(validatedConfig['start-time']),\n      endTime: DateTime.fromISO(validatedConfig['end-time']),\n      interval: validatedConfig.interval,\n      allowPadding: validatedConfig['allow-padding'],\n    };\n\n    const pad = checkForPadding(inputs, timeParams);\n    validatePadding(pad, timeParams);\n\n    const paddedInputs = padInputs(inputs, pad, timeParams);\n\n    const flattenInputs = paddedInputs.reduce(\n      (acc: PluginParams[], input, index) => {\n        const safeInput = Object.assign({}, input, validateInput(input, index));\n        const currentMoment = parseDate(safeInput.timestamp);\n\n        /** Checks if not the first input, then check consistency with previous ones. */\n        if (index > 0) {\n          const previousInput = paddedInputs[index - 1];\n          const previousInputTimestamp = parseDate(previousInput.timestamp);\n\n          /** Checks for timestamps overlap. */\n          if (\n            parseDate(previousInput.timestamp).plus({\n              seconds: previousInput.duration,\n            }) > currentMoment\n          ) {\n            throw new InputValidationError(INVALID_OBSERVATION_OVERLAP);\n          }\n\n          const compareableTime = previousInputTimestamp.plus({\n            seconds: previousInput.duration,\n          });\n\n          const timelineGapSize = currentMoment\n            .diff(compareableTime)\n            .as('seconds');\n\n          /** Checks if there is gap in timeline. */\n          if (timelineGapSize > 1) {\n            acc.push(\n              ...getZeroishInputPerSecondBetweenRange(\n                compareableTime,\n                currentMoment,\n                safeInput\n              )\n            );\n          }\n        }\n        /** Break down current observation. */\n        for (let i = 0; i < safeInput.duration; i++) {\n          const normalizedInput = breakDownInput(safeInput, i);\n\n          acc.push(normalizedInput);\n        }\n\n        return trimInputsByGlobalTimeline(acc, timeParams);\n      },\n      [] as PluginParams[]\n    );\n\n    const sortedInputs = flattenInputs.sort((a, b) =>\n      parseDate(a.timestamp).diff(parseDate(b.timestamp)).as('seconds')\n    );\n\n    return resampleInputs(sortedInputs, timeParams) as PluginParams[];\n  };\n\n  const parseDate = (date: Date | string) => {\n    if (!date) return DateTime.invalid('Invalid date');\n    // dates are passed to time-sync.ts both in ISO 8601 format\n    // and as a Date object (from the deserialization of a YAML file)\n    // if the YAML parser fails to identify as a date, it passes as a string\n    if (isDate(date)) {\n      return DateTime.fromJSDate(date);\n    }\n    if (typeof date === 'string') {\n      return DateTime.fromISO(date);\n    }\n    throw new InputValidationError(\n      `Unexpected date datatype: ${typeof date}: ${date}`\n    );\n  };\n\n  /**\n   * Validates input parameters.\n   */\n  const validateInput = (input: PluginParams, index: number) => {\n    const schema = z.object({\n      timestamp: z\n        .string({\n          required_error: `required in input[${index}]`,\n        })\n        .datetime({\n          message: `invalid datetime in input[${index}]`,\n        })\n        .or(z.date()),\n      duration: z.number(),\n    });\n\n    return validate<z.infer<typeof schema>>(schema, input);\n  };\n\n  /**\n   * Validates global config parameters.\n   */\n  const validateGlobalConfig = () => {\n    if (globalConfig === undefined) {\n      throw new InputValidationError(INVALID_TIME_NORMALIZATION);\n    }\n\n    const schema = z\n      .object({\n        'start-time': z.string().datetime(),\n        'end-time': z.string().datetime(),\n        interval: z.number(),\n        'allow-padding': z.boolean(),\n      })\n      .refine(data => data['start-time'] < data['end-time'], {\n        message: '`start-time` should be lower than `end-time`',\n      });\n\n    return validate<z.infer<typeof schema>>(schema, globalConfig);\n  };\n\n  /**\n   * Calculates minimal factor.\n   */\n  const convertPerInterval = (value: number, duration: number) =>\n    value / duration;\n\n  /**\n   * Normalize time per given second.\n   */\n  const normalizeTimePerSecond = (\n    currentRoundMoment: Date | string,\n    i: number\n  ) => {\n    const thisMoment = parseDate(currentRoundMoment).startOf('second');\n    return thisMoment.plus({seconds: i});\n  };\n  /**\n   * Breaks down input per minimal time unit.\n   */\n  const breakDownInput = (input: PluginParams, i: number) => {\n    const inputKeys = Object.keys(input);\n\n    return inputKeys.reduce((acc, key) => {\n      const method = parameterize.getAggregationMethod(key);\n\n      if (key === 'timestamp') {\n        const perSecond = normalizeTimePerSecond(input.timestamp, i);\n        acc[key] = perSecond.toUTC().toISO() ?? '';\n\n        return acc;\n      }\n\n      /** @todo use user defined resolution later */\n      if (key === 'duration') {\n        acc[key] = 1;\n\n        return acc;\n      }\n\n      acc[key] =\n        method === 'sum'\n          ? convertPerInterval(input[key], input['duration'])\n          : input[key];\n\n      return acc;\n    }, {} as PluginParams);\n  };\n\n  /**\n   * Populates object to fill the gaps in observational timeline using zeroish values.\n   */\n  const fillWithZeroishInput = (\n    input: PluginParams,\n    missingTimestamp: DateTimeMaybeValid\n  ) => {\n    const metrics = Object.keys(input);\n\n    return metrics.reduce((acc, metric) => {\n      if (metric === 'timestamp') {\n        acc[metric] = missingTimestamp.startOf('second').toUTC().toISO() ?? '';\n\n        return acc;\n      }\n\n      /** @todo later will be changed to user defined interval */\n      if (metric === 'duration') {\n        acc[metric] = 1;\n\n        return acc;\n      }\n\n      if (metric === 'time-reserved') {\n        acc[metric] = acc['duration'];\n\n        return acc;\n      }\n\n      const method = parameterize.getAggregationMethod(metric);\n\n      if (method === 'avg' || method === 'sum') {\n        acc[metric] = 0;\n\n        return acc;\n      }\n\n      acc[metric] = input[metric];\n\n      return acc;\n    }, {} as PluginParams);\n  };\n\n  /**\n   * Checks if `error on padding` is enabled and padding is needed. If so, then throws error.\n   */\n  const validatePadding = (pad: PaddingReceipt, params: TimeParams): void => {\n    const {start, end} = pad;\n    const isPaddingNeeded = start || end;\n    if (!params.allowPadding && isPaddingNeeded) {\n      throw new InputValidationError(AVOIDING_PADDING_BY_EDGES(start, end));\n    }\n  };\n\n  /**\n   * Checks if padding is needed either at start of the timeline or the end and returns status.\n   */\n  const checkForPadding = (\n    inputs: PluginParams[],\n    params: TimeParams\n  ): PaddingReceipt => {\n    const startDiffInSeconds = parseDate(inputs[0].timestamp)\n      .diff(params.startTime)\n      .as('seconds');\n\n    const lastInput = inputs[inputs.length - 1];\n\n    const endDiffInSeconds = parseDate(lastInput.timestamp)\n      .plus({second: lastInput.duration})\n      .diff(params.endTime)\n      .as('seconds');\n\n    return {\n      start: startDiffInSeconds > 0,\n      end: endDiffInSeconds < 0,\n    };\n  };\n\n  /**\n   * Iterates over given inputs frame, meanwhile checking if aggregation method is `sum`, then calculates it.\n   * For methods is `avg` and `none` calculating average of the frame.\n   */\n  const resampleInputFrame = (inputsInTimeslot: PluginParams[]) => {\n    return inputsInTimeslot.reduce((acc, input, index, inputs) => {\n      const metrics = Object.keys(input);\n\n      metrics.forEach(metric => {\n        const method = parameterize.getAggregationMethod(metric);\n        acc[metric] = acc[metric] ?? 0;\n\n        if (metric === 'timestamp') {\n          acc[metric] = inputs[0][metric];\n\n          return;\n        }\n\n        if (method === 'sum') {\n          acc[metric] += input[metric];\n\n          return;\n        }\n\n        if (method === 'none') {\n          acc[metric] = input[metric];\n\n          return;\n        }\n\n        /**\n         * If timeslot contains records more than one, then divide each metric by the timeslot length,\n         *  so that their sum yields the timeslot average.\n         */\n        if (\n          inputsInTimeslot.length > 1 &&\n          index === inputsInTimeslot.length - 1\n        ) {\n          acc[metric] /= inputsInTimeslot.length;\n\n          return;\n        }\n\n        acc[metric] += input[metric];\n      });\n\n      return acc;\n    }, {} as PluginParams);\n  };\n\n  /**\n   * Takes each array frame with interval length, then aggregating them together as from units.yaml file.\n   */\n  const resampleInputs = (inputs: PluginParams[], params: TimeParams) => {\n    return inputs.reduce((acc: PluginParams[], _input, index, inputs) => {\n      const frameStart = index * params.interval;\n      const frameEnd = (index + 1) * params.interval;\n      const inputsFrame = inputs.slice(frameStart, frameEnd);\n\n      const resampledInput = resampleInputFrame(inputsFrame);\n\n      /** Checks if resampled input is not empty, then includes in result. */\n      if (Object.keys(resampledInput).length > 0) {\n        acc.push(resampledInput);\n      }\n\n      return acc;\n    }, [] as PluginParams[]);\n  };\n\n  /**\n   * Pads zeroish inputs from the beginning or at the end of the inputs if needed.\n   */\n  const padInputs = (\n    inputs: PluginParams[],\n    pad: PaddingReceipt,\n    params: TimeParams\n  ): PluginParams[] => {\n    const {start, end} = pad;\n    const paddedFromBeginning = [];\n\n    if (start) {\n      paddedFromBeginning.push(\n        ...getZeroishInputPerSecondBetweenRange(\n          params.startTime,\n          parseDate(inputs[0].timestamp),\n          inputs[0]\n        )\n      );\n    }\n\n    const paddedArray = paddedFromBeginning.concat(inputs);\n\n    if (end) {\n      const lastInput = inputs[inputs.length - 1];\n      const lastInputEnd = parseDate(lastInput.timestamp).plus({\n        seconds: lastInput.duration,\n      });\n      paddedArray.push(\n        ...getZeroishInputPerSecondBetweenRange(\n          lastInputEnd,\n          params.endTime.plus({seconds: 1}),\n          lastInput\n        )\n      );\n    }\n    return paddedArray;\n  };\n\n  const getZeroishInputPerSecondBetweenRange = (\n    startDate: DateTimeMaybeValid,\n    endDate: DateTimeMaybeValid,\n    templateInput: PluginParams\n  ) => {\n    const array: PluginParams[] = [];\n    const dateRange = Interval.fromDateTimes(startDate, endDate);\n    for (const interval of dateRange.splitBy({second: 1})) {\n      array.push(\n        fillWithZeroishInput(\n          templateInput,\n          // as far as I can tell, start will never be null\n          // because if we pass an invalid start/endDate to\n          // Interval, we get a zero length array as the range\n          interval.start || DateTime.invalid('not expected - start is null')\n        )\n      );\n    }\n    return array;\n  };\n\n  /*\n   * Checks if input's timestamp is included in global specified period then leaves it, otherwise.\n   */\n  const trimInputsByGlobalTimeline = (\n    inputs: PluginParams[],\n    params: TimeParams\n  ): PluginParams[] => {\n    return inputs.reduce((acc: PluginParams[], item) => {\n      const {timestamp} = item;\n\n      if (\n        parseDate(timestamp) >= params.startTime &&\n        parseDate(timestamp) <= params.endTime\n      ) {\n        acc.push(item);\n      }\n\n      return acc;\n    }, [] as PluginParams[]);\n  };\n\n  return {metadata, execute};\n};\n"]}

package/build/config/config.js

@@ -52,7 +52,7 @@ exports.CONFIG = {
   `,
     },
     GITHUB_PATH: 'https://github.com',
-    NATIVE_PLUGIN: 'if-models',
+    NATIVE_PLUGIN: 'if-plugins',
     AGGREGATION_ADDITIONAL_PARAMS: ['timestamp', 'duration'],
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/config/params.js

@@ -97,11 +97,21 @@ exports.PARAMETERS = {
         unit: 'None',
         aggregation: 'none',
     },
+    'cloud/region': {
+        description: 'region cloud instance runs in',
+        unit: 'None',
+        aggregation: 'none',
+    },
     'cloud/vendor': {
         description: 'Name of the cloud service provider in the ccf model. Can be aws, gcp or azure',
         unit: 'None',
         aggregation: 'none',
     },
+    name: {
+        description: 'arbitrary name parameter.',
+        unit: 'None',
+        aggregation: 'none',
+    },
     'ram-alloc': {
         description: 'refers to GB of memory allocated.',
         unit: 'GB',
@@ -142,5 +152,50 @@ exports.PARAMETERS = {
         unit: 'count',
         aggregation: 'none',
     },
+    'vcpus-allocated': {
+        description: 'number of vcpus allocated to particular resource',
+        unit: 'count',
+        aggregation: 'none',
+    },
+    'vcpus-total': {
+        description: 'total number of vcpus available on a particular resource',
+        unit: 'count',
+        aggregation: 'none',
+    },
+    'memory-available': {
+        description: 'total amount of memory available on a particular resource',
+        unit: 'GB',
+        aggregation: 'none',
+    },
+    'physical-processor': {
+        description: 'name of the physical processor being used in a specific instance type',
+        unit: 'None',
+        aggregation: 'none',
+    },
+    'cloud/region-cfe': {
+        description: 'cloud region name in cfe format',
+        unit: 'None',
+        aggregation: 'none',
+    },
+    'cloud/region-em-zone-id': {
+        description: 'cloud region name in electricity maps format',
+        unit: 'None',
+        aggregation: 'none',
+    },
+    'cloud/region-wt-id': {
+        description: 'cloud region name in watt-time format',
+        unit: 'None',
+        aggregation: 'none',
+    },
+    'cloud/region-location': {
+        description: 'cloud region name in our IF format',
+        unit: 'None',
+        aggregation: 'none',
+    },
+    'cloud/region-geolocation': {
+        description: 'location expressed as decimal coordinates (lat/lon)',
+        unit: 'decimal degrees',
+        aggregation: 'none',
+    },
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"params.js","sourceRoot":"","sources":["../../src/config/params.ts"],"names":[],"mappings":"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","sourcesContent":["import {Parameters} from '../types/parameters';\n\nexport const PARAMETERS: Parameters = {\n  carbon: {\n    description: 'an amount of carbon emitted into the atmosphere',\n    unit: 'gCO2e',\n    aggregation: 'sum',\n  },\n  'cpu/number-cores': {\n    description: 'number of cores available',\n    unit: 'cores',\n    aggregation: 'none',\n  },\n  'cpu/utilization': {\n    description: 'refers to CPU utilization.',\n    unit: 'percentage',\n    aggregation: 'avg',\n  },\n  'disk-io': {\n    description: 'refers to GB of data written/read from disk',\n    unit: 'GB',\n    aggregation: 'sum',\n  },\n  duration: {\n    description: 'refers to the duration of the input',\n    unit: 'seconds',\n    aggregation: 'sum',\n  },\n  energy: {\n    description: 'amount of energy utilised by the component',\n    unit: 'kWh',\n    aggregation: 'sum',\n  },\n  'cpu/energy': {\n    description: 'Energy consumed by the CPU of the component',\n    unit: 'kWh',\n    aggregation: 'sum',\n  },\n  'device/expected-lifespan': {\n    description: 'Total Expected Lifespan of the Component in Seconds',\n    unit: 'seconds',\n    aggregation: 'sum',\n  },\n  'memory/energy': {\n    description: 'Energy consumed by the Memory of the component',\n    unit: 'kWh',\n    aggregation: 'sum',\n  },\n  'carbon-embodied': {\n    description: 'Embodied Emissions of the component',\n    unit: 'gCO2e',\n    aggregation: 'sum',\n  },\n  'network/energy': {\n    description: 'Energy consumed by the Network of the component',\n    unit: 'kWh',\n    aggregation: 'sum',\n  },\n  'functional-unit': {\n    description:\n      'the name of the functional unit in which the final SCI value should be expressed, e.g. requests, users',\n    unit: 'none',\n    aggregation: 'sum',\n  },\n  'functional-unit-time': {\n    description:\n      'string describing the unit of time in which the final SCI calculation should be expressed, e.g. \"1-min\"',\n    unit: 'none',\n    aggregation: 'none',\n  },\n  'gpu-util': {\n    description: 'refers to CPU utilization.',\n    unit: 'percentage',\n    aggregation: 'avg',\n  },\n  'grid/carbon-intensity': {\n    description: 'Carbon intensity for the grid',\n    unit: 'gCO2eq/kWh',\n    aggregation: 'avg',\n  },\n  'cloud/instance-type': {\n    description: 'Type of Cloud Instance name used in the cloud provider APIs',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  geolocation: {\n    description:\n      'Geographic location of provider as string (for watt-time model it is provided as latitude and longitude, comma separated, in decimal degrees)',\n    unit: 'None (decimal degrees for watt-time model)',\n    aggregation: 'none',\n  },\n  'carbon-operational': {\n    description: 'Operational Emissions of the component',\n    unit: 'gCO2e',\n    aggregation: 'sum',\n  },\n  'cpu/name': {\n    description: 'Name of the physical processor',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  'cloud/vendor': {\n    description:\n      'Name of the cloud service provider in the ccf model. Can be aws, gcp or azure',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  'ram-alloc': {\n    description: 'refers to GB of memory allocated.',\n    unit: 'GB',\n    aggregation: 'avg',\n  },\n  'ram-util': {\n    description: 'refers to percentage of memory utilized.',\n    unit: 'percentage',\n    aggregation: 'avg',\n  },\n  'resources-reserved': {\n    description: 'resources reserved for an application',\n    unit: 'count',\n    aggregation: 'none',\n  },\n  'cpu/thermal-design-power': {\n    description: 'thermal design power for a processor',\n    unit: 'kwh',\n    aggregation: 'avg',\n  },\n  'device/emissions-embodied': {\n    description: 'total embodied emissions of some component',\n    unit: 'gCO2e',\n    aggregation: 'sum',\n  },\n  timestamp: {\n    description: 'refers to the time of occurrence of the input',\n    unit: 'RFC3339',\n    aggregation: 'none',\n  },\n  'time-reserved': {\n    description: 'time reserved for a component',\n    unit: 'seconds',\n    aggregation: 'avg',\n  },\n  'resources-total': {\n    description: 'total resources available',\n    unit: 'count',\n    aggregation: 'none',\n  },\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"params.js","sourceRoot":"","sources":["../../src/config/params.ts"],"names":[],"mappings":"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","sourcesContent":["import {Parameters} from '../types/parameters';\n\nexport const PARAMETERS: Parameters = {\n  carbon: {\n    description: 'an amount of carbon emitted into the atmosphere',\n    unit: 'gCO2e',\n    aggregation: 'sum',\n  },\n  'cpu/number-cores': {\n    description: 'number of cores available',\n    unit: 'cores',\n    aggregation: 'none',\n  },\n  'cpu/utilization': {\n    description: 'refers to CPU utilization.',\n    unit: 'percentage',\n    aggregation: 'avg',\n  },\n  'disk-io': {\n    description: 'refers to GB of data written/read from disk',\n    unit: 'GB',\n    aggregation: 'sum',\n  },\n  duration: {\n    description: 'refers to the duration of the input',\n    unit: 'seconds',\n    aggregation: 'sum',\n  },\n  energy: {\n    description: 'amount of energy utilised by the component',\n    unit: 'kWh',\n    aggregation: 'sum',\n  },\n  'cpu/energy': {\n    description: 'Energy consumed by the CPU of the component',\n    unit: 'kWh',\n    aggregation: 'sum',\n  },\n  'device/expected-lifespan': {\n    description: 'Total Expected Lifespan of the Component in Seconds',\n    unit: 'seconds',\n    aggregation: 'sum',\n  },\n  'memory/energy': {\n    description: 'Energy consumed by the Memory of the component',\n    unit: 'kWh',\n    aggregation: 'sum',\n  },\n  'carbon-embodied': {\n    description: 'Embodied Emissions of the component',\n    unit: 'gCO2e',\n    aggregation: 'sum',\n  },\n  'network/energy': {\n    description: 'Energy consumed by the Network of the component',\n    unit: 'kWh',\n    aggregation: 'sum',\n  },\n  'functional-unit': {\n    description:\n      'the name of the functional unit in which the final SCI value should be expressed, e.g. requests, users',\n    unit: 'none',\n    aggregation: 'sum',\n  },\n  'functional-unit-time': {\n    description:\n      'string describing the unit of time in which the final SCI calculation should be expressed, e.g. \"1-min\"',\n    unit: 'none',\n    aggregation: 'none',\n  },\n  'gpu-util': {\n    description: 'refers to CPU utilization.',\n    unit: 'percentage',\n    aggregation: 'avg',\n  },\n  'grid/carbon-intensity': {\n    description: 'Carbon intensity for the grid',\n    unit: 'gCO2eq/kWh',\n    aggregation: 'avg',\n  },\n  'cloud/instance-type': {\n    description: 'Type of Cloud Instance name used in the cloud provider APIs',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  geolocation: {\n    description:\n      'Geographic location of provider as string (for watt-time model it is provided as latitude and longitude, comma separated, in decimal degrees)',\n    unit: 'None (decimal degrees for watt-time model)',\n    aggregation: 'none',\n  },\n  'carbon-operational': {\n    description: 'Operational Emissions of the component',\n    unit: 'gCO2e',\n    aggregation: 'sum',\n  },\n  'cpu/name': {\n    description: 'Name of the physical processor',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  'cloud/region': {\n    description: 'region cloud instance runs in',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  'cloud/vendor': {\n    description:\n      'Name of the cloud service provider in the ccf model. Can be aws, gcp or azure',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  name: {\n    description: 'arbitrary name parameter.',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  'ram-alloc': {\n    description: 'refers to GB of memory allocated.',\n    unit: 'GB',\n    aggregation: 'avg',\n  },\n  'ram-util': {\n    description: 'refers to percentage of memory utilized.',\n    unit: 'percentage',\n    aggregation: 'avg',\n  },\n  'resources-reserved': {\n    description: 'resources reserved for an application',\n    unit: 'count',\n    aggregation: 'none',\n  },\n  'cpu/thermal-design-power': {\n    description: 'thermal design power for a processor',\n    unit: 'kwh',\n    aggregation: 'avg',\n  },\n  'device/emissions-embodied': {\n    description: 'total embodied emissions of some component',\n    unit: 'gCO2e',\n    aggregation: 'sum',\n  },\n  timestamp: {\n    description: 'refers to the time of occurrence of the input',\n    unit: 'RFC3339',\n    aggregation: 'none',\n  },\n  'time-reserved': {\n    description: 'time reserved for a component',\n    unit: 'seconds',\n    aggregation: 'avg',\n  },\n  'resources-total': {\n    description: 'total resources available',\n    unit: 'count',\n    aggregation: 'none',\n  },\n  'vcpus-allocated': {\n    description: 'number of vcpus allocated to particular resource',\n    unit: 'count',\n    aggregation: 'none',\n  },\n  'vcpus-total': {\n    description: 'total number of vcpus available on a particular resource',\n    unit: 'count',\n    aggregation: 'none',\n  },\n  'memory-available': {\n    description: 'total amount of memory available on a particular resource',\n    unit: 'GB',\n    aggregation: 'none',\n  },\n  'physical-processor': {\n    description:\n      'name of the physical processor being used in a specific instance type',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  'cloud/region-cfe': {\n    description: 'cloud region name in cfe format',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  'cloud/region-em-zone-id': {\n    description: 'cloud region name in electricity maps format',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  'cloud/region-wt-id': {\n    description: 'cloud region name in watt-time format',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  'cloud/region-location': {\n    description: 'cloud region name in our IF format',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  'cloud/region-geolocation': {\n    description: 'location expressed as decimal coordinates (lat/lon)',\n    unit: 'decimal degrees',\n    aggregation: 'none',\n  },\n};\n"]}