@grnsft/if 0.7.0 → 0.7.1

package/build/if-run/builtins/time-converter/index.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeConverter = void 0;
+const zod_1 = require("zod");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+const utils_1 = require("@grnsft/if-core/utils");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("./config");
+const config_2 = require("../../config");
+const { ConfigError } = utils_1.ERRORS;
+const { MISSING_CONFIG } = config_2.STRINGS;
+exports.TimeConverter = (0, interfaces_1.PluginFactory)({
+    configValidation: (config) => {
+        if (!config || !Object.keys(config)?.length) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        const timeUnitsValues = Object.keys(config_1.TIME_UNITS_IN_SECONDS);
+        const originalTimeUnitValuesWithDuration = [
+            'duration',
+            ...timeUnitsValues,
+        ];
+        const originalTimeUnitValues = timeUnitsValues;
+        const configSchema = zod_1.z.object({
+            'input-parameter': zod_1.z.string(),
+            'original-time-unit': zod_1.z.enum(originalTimeUnitValues),
+            'new-time-unit': zod_1.z.enum(originalTimeUnitValuesWithDuration),
+            'output-parameter': zod_1.z.string().min(1),
+        });
+        return (0, validations_1.validate)(configSchema, config);
+    },
+    inputValidation: (input, config) => {
+        const inputParameter = config['input-parameter'];
+        const schema = zod_1.z.object({
+            duration: zod_1.z.number().gte(1),
+            [inputParameter]: zod_1.z.number(),
+        });
+        return (0, validations_1.validate)(schema, input);
+    },
+    implementation: async (inputs, config) => {
+        const outputParameter = config['output-parameter'];
+        return inputs.map(input => ({
+            ...input,
+            [outputParameter]: calculateEnergy(input, config),
+        }));
+    },
+    allowArithmeticExpressions: ['input-parameter'],
+});
+/**
+ * Calculates the energy for given period.
+ */
+const calculateEnergy = (input, config) => {
+    const { 'original-time-unit': originalTimeUnit, 'input-parameter': inputParameter, 'new-time-unit': newTimeUnit, } = config;
+    const originalTimeUnitInSeoncds = config_1.TIME_UNITS_IN_SECONDS[originalTimeUnit];
+    const energyPerPeriod = isNaN(Number(inputParameter))
+        ? input[inputParameter]
+        : inputParameter;
+    const timeUnit = newTimeUnit === 'duration'
+        ? input.duration
+        : config_1.TIME_UNITS_IN_SECONDS[newTimeUnit];
+    const result = (energyPerPeriod / originalTimeUnitInSeoncds) * timeUnit;
+    return Number(result.toFixed(6));
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/time-sync/index.d.ts

@@ -0,0 +1,31 @@
+import { PluginParams, MappingParams, TimeNormalizerConfig } from '@grnsft/if-core/types';
+/**
+ * Time synchronization plugin converted into framework integrated tool.
+ * It can't be requested in `initialize.plugins` section anymore. Instead describe configuration in context.
+ * @example
+ * ```yaml
+ * name: time-sync
+ * description: sample in time sync lib
+ * tags: sample, time, sync
+ * time-sync:
+ *   start-time: '2023-12-12T00:00:00.000Z'
+ *   end-time: '2023-12-12T00:01:00.000Z'
+ *   interval: 5
+ *   allow-padding: true
+ * ```
+ */
+export declare const TimeSync: (config: TimeNormalizerConfig | undefined, parametersMetadata: import("@grnsft/if-core/types").PluginParametersMetadata, mapping: MappingParams) => {
+    metadata: {
+        inputs: {
+            [x: string]: {
+                description: string;
+                unit: string;
+                'aggregation-method': import("@grnsft/if-core/types").AggregationOptions;
+            };
+        };
+        outputs: import("@grnsft/if-core/types").ParameterMetadata;
+    };
+    execute: (inputs: PluginParams[]) => Promise<{
+        [x: string]: any;
+    }[]>;
+};

package/build/if-run/builtins/time-sync/index.js

@@ -0,0 +1,371 @@
+"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 utils_1 = require("@grnsft/if-core/utils");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const aggregate_1 = require("../../lib/aggregate");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+luxon_1.Settings.defaultZone = 'utc';
+const { ConfigError, InvalidDateInInputError, InvalidPaddingError, InvalidInputError, } = utils_1.ERRORS;
+const { INCOMPATIBLE_RESOLUTION_WITH_INTERVAL, INCOMPATIBLE_RESOLUTION_WITH_GAPS, INCOMPATIBLE_RESOLUTION_WITH_INPUTS, INVALID_OBSERVATION_OVERLAP, AVOIDING_PADDING_BY_EDGES, INVALID_DATE_TYPE, START_LOWER_END, MISSING_CONFIG, } = config_1.STRINGS;
+/**
+ * Time synchronization plugin converted into framework integrated tool.
+ * It can't be requested in `initialize.plugins` section anymore. Instead describe configuration in context.
+ * @example
+ * ```yaml
+ * name: time-sync
+ * description: sample in time sync lib
+ * tags: sample, time, sync
+ * time-sync:
+ *   start-time: '2023-12-12T00:00:00.000Z'
+ *   end-time: '2023-12-12T00:01:00.000Z'
+ *   interval: 5
+ *   allow-padding: true
+ * ```
+ */
+exports.TimeSync = (0, interfaces_1.PluginFactory)({
+    metadata: {
+        inputs: {
+            timestamp: {
+                description: 'refers to the time of occurrence of the input',
+                unit: 'RFC3339',
+                'aggregation-method': {
+                    time: 'none',
+                    component: 'none',
+                },
+            },
+            duration: {
+                description: 'refers to the duration of the input',
+                unit: 'seconds',
+                'aggregation-method': {
+                    time: 'sum',
+                    component: 'none',
+                },
+            },
+        },
+    },
+    configValidation: (config) => {
+        if (!config || !Object.keys(config)?.length) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        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(),
+            'upsampling-resolution': zod_1.z.number().min(1).optional(),
+        })
+            .refine(data => data['start-time'] < data['end-time'], {
+            message: START_LOWER_END,
+        });
+        return (0, validations_1.validate)(schema, config);
+    },
+    inputValidation: (input, _config, index) => {
+        const schema = zod_1.z.object({
+            timestamp: zod_1.z.string().datetime({}).or(zod_1.z.date()),
+            duration: zod_1.z.number(),
+        });
+        return (0, validations_1.validate)(schema, input, index);
+    },
+    implementation: async (inputs, config, mapping) => {
+        /**
+         * Checks if a given duration is compatible with a given timeStep. If not, throws an error
+         */
+        const validateIntervalForResample = (duration, timeStep, errorMessage) => {
+            if (duration % timeStep !== 0) {
+                throw new ConfigError(errorMessage);
+            }
+        };
+        /**
+         * Dates are passed to `time-sync` 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.
+         */
+        const parseDate = (date) => {
+            if (!date) {
+                return luxon_1.DateTime.invalid('Invalid date');
+            }
+            if ((0, types_1.isDate)(date)) {
+                return luxon_1.DateTime.fromJSDate(date);
+            }
+            if (typeof date === 'string') {
+                return luxon_1.DateTime.fromISO(date);
+            }
+            throw new InvalidDateInInputError(INVALID_DATE_TYPE(date));
+        };
+        /**
+         * Calculates minimal factor.
+         */
+        const convertPerInterval = (value, duration, timeStep) => {
+            const samplesNumber = duration / timeStep;
+            return value / samplesNumber;
+        };
+        /**
+         * 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, params) => {
+            const metrics = Object.keys(input);
+            const timeStep = params.upsamplingResolution;
+            return metrics.reduce((acc, metric) => {
+                const aggregationParams = (0, aggregate_1.getAggregationInfoFor)(metric);
+                if (metric === 'timestamp') {
+                    const perSecond = normalizeTimePerSecond(input.timestamp, i);
+                    acc[metric] = perSecond.toUTC().toISO() ?? '';
+                    return acc;
+                }
+                if (metric === 'duration') {
+                    acc[metric] = timeStep;
+                    return acc;
+                }
+                if (aggregationParams.time === 'none') {
+                    acc[metric] = null;
+                    return acc;
+                }
+                acc[metric] =
+                    aggregationParams.time === 'sum'
+                        ? convertPerInterval(input[metric], input['duration'], timeStep)
+                        : input[metric];
+                return acc;
+            }, {});
+        };
+        /**
+         * Populates object to fill the gaps in observational timeline using zeroish values.
+         */
+        const fillWithZeroishInput = (input, missingTimestamp, timeStep) => {
+            const metrics = Object.keys(input);
+            return metrics.reduce((acc, metric) => {
+                if (metric === 'timestamp') {
+                    acc[metric] =
+                        missingTimestamp.startOf('second').toUTC().toISO() ?? '';
+                    return acc;
+                }
+                if (metric === 'duration') {
+                    acc[metric] = timeStep;
+                    return acc;
+                }
+                if (metric === 'time-reserved' ||
+                    (mapping &&
+                        mapping['time-reserved'] &&
+                        metric === mapping['time-reserved'])) {
+                    acc[metric] = acc['duration'];
+                    return acc;
+                }
+                const aggregationParams = (0, aggregate_1.getAggregationInfoFor)(metric);
+                if (aggregationParams.time === 'none') {
+                    acc[metric] = null;
+                    return acc;
+                }
+                if (aggregationParams.time === 'avg' ||
+                    aggregationParams.time === 'sum') {
+                    acc[metric] = 0;
+                    return acc;
+                }
+                if (aggregationParams.time === 'copy') {
+                    acc[metric] = input[metric];
+                    return acc;
+                }
+                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 InvalidPaddingError(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: eval(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) => inputsInTimeslot.reduce((acc, input, index, inputs) => {
+            const metrics = Object.keys(input);
+            metrics.forEach(metric => {
+                const aggregationParams = (0, aggregate_1.getAggregationInfoFor)(metric);
+                if (metric === 'timestamp') {
+                    acc[metric] = inputs[0][metric];
+                    return;
+                }
+                if (metric === 'duration') {
+                    aggregationParams.time = 'sum';
+                }
+                if (aggregationParams.time === 'none') {
+                    acc[metric] = null;
+                    return;
+                }
+                acc[metric] = acc[metric] ?? 0;
+                if (aggregationParams.time === 'sum') {
+                    acc[metric] += input[metric];
+                    return;
+                }
+                if (aggregationParams.time === 'copy') {
+                    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) => inputs.reduce((acc, _input, index, inputs) => {
+            const frameStart = (index * params.interval) / params.upsamplingResolution;
+            const frameEnd = ((index + 1) * params.interval) / params.upsamplingResolution;
+            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({
+                    startDate: params.startTime,
+                    endDate: parseDate(inputs[0].timestamp),
+                    timeStep: params.upsamplingResolution,
+                }, inputs[0]));
+            }
+            const paddedArray = paddedFromBeginning.concat(inputs);
+            if (end) {
+                const lastInput = inputs[inputs.length - 1];
+                const lastInputEnd = parseDate(lastInput.timestamp).plus({
+                    seconds: eval(lastInput.duration),
+                });
+                paddedArray.push(...getZeroishInputPerSecondBetweenRange({
+                    startDate: lastInputEnd,
+                    endDate: params.endTime,
+                    timeStep: params.upsamplingResolution,
+                }, lastInput));
+            }
+            return paddedArray;
+        };
+        /**
+         * Brakes down the given range by 1 second, and generates zeroish values.
+         */
+        const getZeroishInputPerSecondBetweenRange = (params, input) => {
+            const array = [];
+            validateIntervalForResample(params.endDate.diff(params.startDate).as('seconds'), params.timeStep, INCOMPATIBLE_RESOLUTION_WITH_GAPS);
+            const dateRange = luxon_1.Interval.fromDateTimes(params.startDate, params.endDate);
+            for (const interval of dateRange.splitBy({ second: params.timeStep })) {
+                array.push(fillWithZeroishInput(input, 
+                // 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'), params.timeStep));
+            }
+            return array;
+        };
+        /*
+         * Checks if input's timestamp is included in global specified period then leaves it, otherwise.
+         */
+        const trimInputsByGlobalTimeline = (inputs, params) => inputs.reduce((acc, item) => {
+            const { timestamp } = item;
+            if (parseDate(timestamp) >= params.startTime &&
+                parseDate(timestamp) <= params.endTime) {
+                acc.push(item);
+            }
+            return acc;
+        }, []);
+        /** Implementation */
+        const timeParams = {
+            startTime: luxon_1.DateTime.fromISO(config['start-time']),
+            endTime: luxon_1.DateTime.fromISO(config['end-time']),
+            interval: config.interval,
+            allowPadding: config['allow-padding'],
+            upsamplingResolution: config['upsampling-resolution']
+                ? config['upsampling-resolution']
+                : 1,
+        };
+        validateIntervalForResample(timeParams.interval, timeParams.upsamplingResolution, INCOMPATIBLE_RESOLUTION_WITH_INTERVAL);
+        const pad = checkForPadding(inputs, timeParams);
+        validatePadding(pad, timeParams);
+        const paddedInputs = padInputs(inputs, pad, timeParams);
+        const flattenInputs = paddedInputs.reduce((acc, input, index) => {
+            const currentMoment = parseDate(input.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: eval(previousInput.duration),
+                }) > currentMoment) {
+                    throw new InvalidInputError(INVALID_OBSERVATION_OVERLAP);
+                }
+                const compareableTime = previousInputTimestamp.plus({
+                    seconds: eval(previousInput.duration),
+                });
+                const timelineGapSize = currentMoment
+                    .diff(compareableTime)
+                    .as('seconds');
+                validateIntervalForResample(input.duration, timeParams.upsamplingResolution, INCOMPATIBLE_RESOLUTION_WITH_INPUTS);
+                if (timelineGapSize > 1) {
+                    /** Checks if there is gap in timeline. */
+                    acc.push(...getZeroishInputPerSecondBetweenRange({
+                        startDate: compareableTime,
+                        endDate: currentMoment,
+                        timeStep: timeParams.upsamplingResolution,
+                    }, input));
+                }
+            }
+            /** Break down current observation. */
+            for (let i = 0; i <= input.duration - timeParams.upsamplingResolution; i += timeParams.upsamplingResolution) {
+                const normalizedInput = breakDownInput(input, i, timeParams);
+                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);
+    },
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/if-run/builtins/time-sync/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {isDate} from 'node:util/types';\n\nimport {Settings, DateTime, DateTimeMaybeValid, Interval} from 'luxon';\nimport {z} from 'zod';\nimport {ERRORS} from '@grnsft/if-core/utils';\nimport {\n  PluginParams,\n  PaddingReceipt,\n  MappingParams,\n  ConfigParams,\n  TimeParams,\n  TimeNormalizerConfig,\n} from '@grnsft/if-core/types';\n\nimport {validate} from '../../../common/util/validations';\n\nimport {STRINGS} from '../../config';\nimport {getAggregationInfoFor} from '../../lib/aggregate';\nimport {PluginFactory} from '@grnsft/if-core/interfaces';\n\nSettings.defaultZone = 'utc';\n\nconst {\n  ConfigError,\n  InvalidDateInInputError,\n  InvalidPaddingError,\n  InvalidInputError,\n} = ERRORS;\n\nconst {\n  INCOMPATIBLE_RESOLUTION_WITH_INTERVAL,\n  INCOMPATIBLE_RESOLUTION_WITH_GAPS,\n  INCOMPATIBLE_RESOLUTION_WITH_INPUTS,\n  INVALID_OBSERVATION_OVERLAP,\n  AVOIDING_PADDING_BY_EDGES,\n  INVALID_DATE_TYPE,\n  START_LOWER_END,\n  MISSING_CONFIG,\n} = STRINGS;\n\n/**\n * Time synchronization plugin converted into framework integrated tool.\n * It can't be requested in `initialize.plugins` section anymore. Instead describe configuration in context.\n * @example\n * ```yaml\n * name: time-sync\n * description: sample in time sync lib\n * tags: sample, time, sync\n * time-sync:\n *   start-time: '2023-12-12T00:00:00.000Z'\n *   end-time: '2023-12-12T00:01:00.000Z'\n *   interval: 5\n *   allow-padding: true\n * ```\n */\nexport const TimeSync = PluginFactory<TimeNormalizerConfig>({\n  metadata: {\n    inputs: {\n      timestamp: {\n        description: 'refers to the time of occurrence of the input',\n        unit: 'RFC3339',\n        'aggregation-method': {\n          time: 'none',\n          component: 'none',\n        },\n      },\n      duration: {\n        description: 'refers to the duration of the input',\n        unit: 'seconds',\n        'aggregation-method': {\n          time: 'sum',\n          component: 'none',\n        },\n      },\n    },\n  },\n  configValidation: (config: ConfigParams): TimeNormalizerConfig => {\n    if (!config || !Object.keys(config)?.length) {\n      throw new ConfigError(MISSING_CONFIG);\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        'upsampling-resolution': z.number().min(1).optional(),\n      })\n      .refine(data => data['start-time'] < data['end-time'], {\n        message: START_LOWER_END,\n      });\n\n    return validate<z.infer<typeof schema>>(schema, config);\n  },\n  inputValidation: (input: PluginParams, _config: any, index?: number) => {\n    const schema = z.object({\n      timestamp: z.string().datetime({}).or(z.date()),\n      duration: z.number(),\n    });\n\n    return validate<z.infer<typeof schema>>(schema, input, index);\n  },\n  implementation: async (\n    inputs: PluginParams[],\n    config,\n    mapping?: MappingParams\n  ) => {\n    /**\n     * Checks if a given duration is compatible with a given timeStep. If not, throws an error\n     */\n    const validateIntervalForResample = (\n      duration: number,\n      timeStep: number,\n      errorMessage: string\n    ) => {\n      if (duration % timeStep !== 0) {\n        throw new ConfigError(errorMessage);\n      }\n    };\n\n    /**\n     * Dates are passed to `time-sync` 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     */\n    const parseDate = (date: Date | string) => {\n      if (!date) {\n        return DateTime.invalid('Invalid date');\n      }\n\n      if (isDate(date)) {\n        return DateTime.fromJSDate(date);\n      }\n\n      if (typeof date === 'string') {\n        return DateTime.fromISO(date);\n      }\n\n      throw new InvalidDateInInputError(INVALID_DATE_TYPE(date));\n    };\n\n    /**\n     * Calculates minimal factor.\n     */\n    const convertPerInterval = (\n      value: number,\n      duration: number,\n      timeStep: number\n    ) => {\n      const samplesNumber = duration / timeStep;\n\n      return value / samplesNumber;\n    };\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\n      return thisMoment.plus({seconds: i});\n    };\n\n    /**\n     * Breaks down input per minimal time unit.\n     */\n    const breakDownInput = (\n      input: PluginParams,\n      i: number,\n      params: TimeParams\n    ) => {\n      const metrics = Object.keys(input);\n      const timeStep = params.upsamplingResolution;\n\n      return metrics.reduce((acc, metric) => {\n        const aggregationParams = getAggregationInfoFor(metric);\n\n        if (metric === 'timestamp') {\n          const perSecond = normalizeTimePerSecond(input.timestamp, i);\n          acc[metric] = perSecond.toUTC().toISO() ?? '';\n\n          return acc;\n        }\n\n        if (metric === 'duration') {\n          acc[metric] = timeStep;\n\n          return acc;\n        }\n\n        if (aggregationParams.time === 'none') {\n          acc[metric] = null;\n\n          return acc;\n        }\n\n        acc[metric] =\n          aggregationParams.time === 'sum'\n            ? convertPerInterval(input[metric], input['duration'], timeStep)\n            : input[metric];\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      timeStep: number\n    ) => {\n      const metrics = Object.keys(input);\n      return metrics.reduce((acc, metric) => {\n        if (metric === 'timestamp') {\n          acc[metric] =\n            missingTimestamp.startOf('second').toUTC().toISO() ?? '';\n\n          return acc;\n        }\n\n        if (metric === 'duration') {\n          acc[metric] = timeStep;\n\n          return acc;\n        }\n\n        if (\n          metric === 'time-reserved' ||\n          (mapping &&\n            mapping['time-reserved'] &&\n            metric === mapping['time-reserved'])\n        ) {\n          acc[metric] = acc['duration'];\n\n          return acc;\n        }\n\n        const aggregationParams = getAggregationInfoFor(metric);\n\n        if (aggregationParams.time === 'none') {\n          acc[metric] = null;\n\n          return acc;\n        }\n\n        if (\n          aggregationParams.time === 'avg' ||\n          aggregationParams.time === 'sum'\n        ) {\n          acc[metric] = 0;\n\n          return acc;\n        }\n\n        if (aggregationParams.time === 'copy') {\n          acc[metric] = input[metric];\n          return acc;\n        }\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\n      if (!params.allowPadding && isPaddingNeeded) {\n        throw new InvalidPaddingError(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: eval(lastInput.duration)})\n        .diff(params.endTime)\n        .as('seconds');\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      inputsInTimeslot.reduce((acc, input, index, inputs) => {\n        const metrics = Object.keys(input);\n\n        metrics.forEach(metric => {\n          const aggregationParams = getAggregationInfoFor(metric);\n\n          if (metric === 'timestamp') {\n            acc[metric] = inputs[0][metric];\n\n            return;\n          }\n\n          if (metric === 'duration') {\n            aggregationParams.time = 'sum';\n          }\n\n          if (aggregationParams.time === 'none') {\n            acc[metric] = null;\n            return;\n          }\n\n          acc[metric] = acc[metric] ?? 0;\n\n          if (aggregationParams.time === 'sum') {\n            acc[metric] += input[metric];\n\n            return;\n          }\n\n          if (aggregationParams.time === 'copy') {\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     * 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      inputs.reduce((acc: PluginParams[], _input, index, inputs) => {\n        const frameStart =\n          (index * params.interval) / params.upsamplingResolution;\n        const frameEnd =\n          ((index + 1) * params.interval) / params.upsamplingResolution;\n\n        const inputsFrame = inputs.slice(frameStart, frameEnd);\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     * 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            {\n              startDate: params.startTime,\n              endDate: parseDate(inputs[0].timestamp),\n              timeStep: params.upsamplingResolution,\n            },\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: eval(lastInput.duration),\n        });\n        paddedArray.push(\n          ...getZeroishInputPerSecondBetweenRange(\n            {\n              startDate: lastInputEnd,\n              endDate: params.endTime,\n              timeStep: params.upsamplingResolution,\n            },\n            lastInput\n          )\n        );\n      }\n\n      return paddedArray;\n    };\n\n    /**\n     * Brakes down the given range by 1 second, and generates zeroish values.\n     */\n    const getZeroishInputPerSecondBetweenRange = (\n      params: PluginParams,\n      input: PluginParams\n    ) => {\n      const array: PluginParams[] = [];\n      validateIntervalForResample(\n        params.endDate.diff(params.startDate).as('seconds'),\n        params.timeStep,\n        INCOMPATIBLE_RESOLUTION_WITH_GAPS\n      );\n      const dateRange = Interval.fromDateTimes(\n        params.startDate,\n        params.endDate\n      );\n\n      for (const interval of dateRange.splitBy({second: params.timeStep})) {\n        array.push(\n          fillWithZeroishInput(\n            input,\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            params.timeStep\n          )\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      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    /** Implementation */\n    const timeParams = {\n      startTime: DateTime.fromISO(config['start-time'] as string),\n      endTime: DateTime.fromISO(config['end-time'] as string),\n      interval: config.interval,\n      allowPadding: config['allow-padding'],\n      upsamplingResolution: config['upsampling-resolution']\n        ? config['upsampling-resolution']\n        : 1,\n    };\n    validateIntervalForResample(\n      timeParams.interval,\n      timeParams.upsamplingResolution,\n      INCOMPATIBLE_RESOLUTION_WITH_INTERVAL\n    );\n    const pad = checkForPadding(inputs, timeParams);\n    validatePadding(pad, timeParams);\n    const paddedInputs = padInputs(inputs, pad, timeParams);\n\n    const flattenInputs = paddedInputs.reduce(\n      (acc: PluginParams[], input, index) => {\n        const currentMoment = parseDate(input.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: eval(previousInput.duration),\n            }) > currentMoment\n          ) {\n            throw new InvalidInputError(INVALID_OBSERVATION_OVERLAP);\n          }\n\n          const compareableTime = previousInputTimestamp.plus({\n            seconds: eval(previousInput.duration),\n          });\n\n          const timelineGapSize = currentMoment\n            .diff(compareableTime)\n            .as('seconds');\n\n          validateIntervalForResample(\n            input.duration,\n            timeParams.upsamplingResolution,\n            INCOMPATIBLE_RESOLUTION_WITH_INPUTS\n          );\n\n          if (timelineGapSize > 1) {\n            /** Checks if there is gap in timeline. */\n            acc.push(\n              ...getZeroishInputPerSecondBetweenRange(\n                {\n                  startDate: compareableTime,\n                  endDate: currentMoment,\n                  timeStep: timeParams.upsamplingResolution,\n                },\n                input\n              )\n            );\n          }\n        }\n\n        /** Break down current observation. */\n        for (\n          let i = 0;\n          i <= input.duration - timeParams.upsamplingResolution;\n          i += timeParams.upsamplingResolution\n        ) {\n          const normalizedInput = breakDownInput(input, i, timeParams);\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"]}

package/build/if-run/config/config.d.ts

@@ -0,0 +1,9 @@
+import { ArgumentConfig, ParseOptions } from 'ts-command-line-args';
+import { IfRunArgs } from '../types/process-args';
+export declare const CONFIG: {
+    ARGS: ArgumentConfig<IfRunArgs>;
+    HELP: ParseOptions<any>;
+    GITHUB_PATH: string;
+    NATIVE_PLUGIN: string;
+    AGGREGATION_TIME_METRICS: string[];
+};

package/build/if-run/config/config.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = void 0;
+const config_1 = require("../../common/config");
+const { DISCLAIMER_MESSAGE } = config_1.STRINGS;
+exports.CONFIG = {
+    ARGS: {
+        manifest: {
+            type: String,
+            optional: true,
+            alias: 'm',
+            description: '[path to the input file]',
+        },
+        output: {
+            type: String,
+            optional: true,
+            alias: 'o',
+            description: '[path to the output file]',
+        },
+        'override-params': {
+            type: String,
+            optional: true,
+            alias: 'p',
+            description: '[path to a parameter file that overrides our defaults]',
+        },
+        'no-output': {
+            type: Boolean,
+            optional: true,
+            alias: 'n',
+            description: '[prevent output to the console]',
+        },
+        help: {
+            type: Boolean,
+            optional: true,
+            alias: 'h',
+            description: '[prints out the above help instruction]',
+        },
+        append: {
+            type: Boolean,
+            optional: true,
+            alias: 'a',
+            description: '[append to outputs, instead of overwriting]',
+        },
+        debug: {
+            type: Boolean,
+            optional: true,
+            alias: 'd',
+            description: '[prints out debug logs to the console]',
+        },
+        observe: {
+            type: Boolean,
+            optional: true,
+            description: '[executes only observe pipeline of the manifest]',
+        },
+        regroup: {
+            type: Boolean,
+            optional: true,
+            description: '[executes only regroup pipeline of the manifest]',
+        },
+        compute: {
+            type: Boolean,
+            optional: true,
+            description: '[executes only compute pipeline of the manifest]',
+        },
+    },
+    HELP: {
+        helpArg: 'help',
+        headerContentSections: [
+            { header: 'Impact Framework', content: 'Helpful keywords:' },
+        ],
+        footerContentSections: [
+            { header: 'Green Software Foundation', content: DISCLAIMER_MESSAGE },
+        ],
+    },
+    GITHUB_PATH: 'https://github.com',
+    NATIVE_PLUGIN: 'if-plugins',
+    AGGREGATION_TIME_METRICS: ['timestamp', 'duration'],
+};
+//# sourceMappingURL=data:application/json;base64,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