@grnsft/if
Version:
Impact Framework
82 lines • 19.8 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.STRINGS = void 0;
exports.STRINGS = {
MISSING_METHOD: "Initalization param 'method' is missing.",
MISSING_PATH: "Initalization param 'path' is missing.",
NOT_NATIVE_PLUGIN: (path) => `
You are using plugin ${path} which is not part of the Impact Framework standard library. You should do your own research to ensure the plugins are up to date and accurate. They may not be actively maintained.`,
INVALID_MODULE_PATH: (path, error) => `Provided module \`${path}\` is invalid or not found. ${error ?? ''}
`,
INCOMPATIBLE_RESOLUTION_WITH_INTERVAL: 'The upsampling resolution must be a divisor of the given interval, but the provided value does not satisfy this criteria.',
INCOMPATIBLE_RESOLUTION_WITH_INPUTS: 'The upsampling resolution must be a divisor of all inputs durations, but the provided values do not satisfy this criteria.',
INCOMPATIBLE_RESOLUTION_WITH_GAPS: 'The upsampling resolution must be a divisor of gaps and paddings in the time-series, but the provided values do not satisfy this criteria.',
UNEXPECTED_TIME_CONFIG: 'Unexpected node-level config provided for time-sync plugin.',
AVOIDING_PADDING_BY_EDGES: (start, end) => `Avoiding padding at ${start && end ? 'start and end' : start ? 'start' : 'end'}`,
METRIC_MISSING: (metric, index) => `Aggregation metric ${metric} is not found in inputs[${index}].`,
INVALID_GROUP_KEY: (key) => `Invalid group ${key}.`,
REGROUP_ERROR: 'not an array or should contain at least one key',
UNKNOWN_PARAM: (name) => `Unknown parameter: ${name}. Omitting from the output.`,
NOT_INITALIZED_PLUGIN: (name) => `Not initalized plugin: ${name}. Check if ${name} is in 'manifest.initalize.plugins'.`,
NO_OUTPUT: `
You have not added an output command:
--output <savepath>: will save your output data to the given filepath (do not provide file extension)
Note that for the '--output' option you also need to define the output type in your manifest file. See https://if.greensoftware.foundation/major-concepts/imp-file#initialize`,
UNSUPPORTED_ERROR: (errorName) => `UnsupportedErrorClass: plugin threw error class: ${errorName} that is not recognized by Impact Framework`,
/** Debugging logs */
STARTING_IF: 'Starting IF',
EXITING_IF: 'Exiting IF',
LOADING_MANIFEST: 'Loading manifest',
VALIDATING_MANIFEST: 'Validating manifest',
CAPTURING_RUNTIME_ENVIRONMENT_DATA: 'Capturing runtime environment data',
CHECKING_AGGREGATION_METHOD: (unitName) => `Checking aggregation method for ${unitName}`,
INITIALIZING_PLUGINS: 'Initializing plugins',
INITIALIZING_PLUGIN: (pluginName) => `Initializing \`${pluginName}\` instance`,
LOADING_PLUGIN_FROM_PATH: (pluginName, path) => `Loading ${pluginName} from ${path}`,
COMPUTING_PIPELINE_FOR_NODE: (nodeName) => `Running compute pipeline: \`${nodeName}\` plugin`,
COMPUTING_COMPONENT_PIPELINE: (component) => `**Computing \`${component}\` pipeline**`,
REGROUPING: 'Regrouping',
SKIPPING_REGROUP: 'Already correctly grouped - skipping regrouping.',
OBSERVING: (nodeName) => `Running observe pipeline: \`${nodeName}\` plugin`,
MERGING_DEFAULTS_WITH_INPUT_DATA: 'Merging defaults with input data',
AGGREGATING_OUTPUTS: 'Aggregating outputs',
AGGREGATING_NODE: (nodeName) => `Aggregating node ${nodeName}`,
PREPARING_OUTPUT_DATA: () => {
console.debug('\n');
return 'Preparing output data';
},
EXPORTING_TO_YAML_FILE: (savepath) => `Exporting to yaml file: ${savepath}`,
EMPTY_PIPELINE: `You're using an old style manifest. Please update for phased execution. More information can be found here:
https://if.greensoftware.foundation/major-concepts/imp-file`,
/** Exhaust messages */
OUTPUT_REQUIRED: 'Output path is required, please make sure output is configured properly.',
/** Plugins messages */
INVALID_NAME: '`name` config parameter is empty or contains all spaces',
START_LOWER_END: '`start-time` should be lower than `end-time`',
X_Y_EQUAL: 'The length of `x` and `y` should be equal',
ARRAY_LENGTH_NON_EMPTY: 'the length of the input arrays must be greater than 1',
WITHIN_THE_RANGE: 'The target x value must be within the range of the given x values',
MISSING_CSV_COLUMN: (columnName) => `There is no column with the name: ${columnName}.`,
NO_QUERY_DATA: 'One or more of the given query parameters are not found in the target CSV file column headers.',
INVALID_DATE_TYPE: (date) => `Unexpected date datatype: ${typeof date}: ${date}`,
INVALID_OBSERVATION_OVERLAP: 'Observation timestamps overlap, please check inputs.',
SCI_MISSING_FN_UNIT: (functionalUnit) => `'carbon' and ${functionalUnit} should be present in your input data.`,
MISSING_FUNCTIONAL_UNIT_CONFIG: '`functional-unit` should be provided in your config',
MISSING_FUNCTIONAL_UNIT_INPUT: '`functional-unit` value is missing from input data or it is not a positive integer',
REGEX_MISMATCH: (input, match) => `\`${input}\` does not match the ${match} regex expression`,
MISSING_MIN_MAX: 'Config is missing min or max value',
INVALID_MIN_MAX: (name) => `Min value should not be greater than or equal to max value of ${name}`,
FILE_FETCH_FAILED: (filepath, message) => `Failed fetching the file: ${filepath}.
${message}`,
FILE_READ_FAILED: (filepath, error) => `Failed reading the file: ${filepath}.
${error}`,
ZERO_DIVISION: (moduleName, index) => `-- SKIPPING -- DivisionByZero: you are attempting to divide by zero in ${moduleName} plugin : inputs[${index}]\n`,
MISSING_CONFIG: 'Config is not provided.',
MISSING_INPUT_DATA: (param) => `${param} is missing from the input array, or has nullish value.`,
CONFIG_WARN: (plugins, isMore) => {
const withoutPlugins = 'You have included node-level config in your manifest. IF no longer supports node-level config. The manifest should be refactored to accept all its node-level config from config or input data.';
const withPlugins = `You have included node-level config in your manifest to support \`${plugins}\` plugin${isMore ? 's' : ''}. IF no longer supports node-level config. \`${plugins}\` plugin${isMore ? 's' : ''} should be refactored to accept all its config from config or input data.`;
return plugins.length ? withPlugins : withoutPlugins;
},
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"strings.js","sourceRoot":"","sources":["../../../src/if-run/config/strings.ts"],"names":[],"mappings":"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","sourcesContent":["export const STRINGS = {\n  MISSING_METHOD: \"Initalization param 'method' is missing.\",\n  MISSING_PATH: \"Initalization param 'path' is missing.\",\n  NOT_NATIVE_PLUGIN: (path: string) =>\n    `\n  You are using plugin ${path} which is not part of the Impact Framework standard library. You should do your own research to ensure the plugins are up to date and accurate. They may not be actively maintained.`,\n  INVALID_MODULE_PATH: (path: string, error?: any) =>\n    `Provided module \\`${path}\\` is invalid or not found. ${error ?? ''}\n`,\n  INCOMPATIBLE_RESOLUTION_WITH_INTERVAL:\n    'The upsampling resolution must be a divisor of the given interval, but the provided value does not satisfy this criteria.',\n  INCOMPATIBLE_RESOLUTION_WITH_INPUTS:\n    'The upsampling resolution must be a divisor of all inputs durations, but the provided values do not satisfy this criteria.',\n  INCOMPATIBLE_RESOLUTION_WITH_GAPS:\n    'The upsampling resolution must be a divisor of gaps and paddings in the time-series, but the provided values do not satisfy this criteria.',\n  UNEXPECTED_TIME_CONFIG:\n    'Unexpected node-level config provided for time-sync plugin.',\n  AVOIDING_PADDING_BY_EDGES: (start: boolean, end: boolean) =>\n    `Avoiding padding at ${\n      start && end ? 'start and end' : start ? 'start' : 'end'\n    }`,\n  METRIC_MISSING: (metric: string, index: number) =>\n    `Aggregation metric ${metric} is not found in inputs[${index}].`,\n  INVALID_GROUP_KEY: (key: string) => `Invalid group ${key}.`,\n  REGROUP_ERROR: 'not an array or should contain at least one key',\n  UNKNOWN_PARAM: (name: string) =>\n    `Unknown parameter: ${name}. Omitting from the output.`,\n  NOT_INITALIZED_PLUGIN: (name: string) =>\n    `Not initalized plugin: ${name}. Check if ${name} is in 'manifest.initalize.plugins'.`,\n  NO_OUTPUT: `\nYou have not added an output command: \n--output <savepath>: will save your output data to the given filepath (do not provide file extension)\nNote that for the '--output' option you also need to define the output type in your manifest file. See https://if.greensoftware.foundation/major-concepts/imp-file#initialize`,\n  UNSUPPORTED_ERROR: (errorName: string) =>\n    `UnsupportedErrorClass: plugin threw error class: ${errorName} that is not recognized by Impact Framework`,\n  /** Debugging logs */\n  STARTING_IF: 'Starting IF',\n  EXITING_IF: 'Exiting IF',\n  LOADING_MANIFEST: 'Loading manifest',\n  VALIDATING_MANIFEST: 'Validating manifest',\n  CAPTURING_RUNTIME_ENVIRONMENT_DATA: 'Capturing runtime environment data',\n  CHECKING_AGGREGATION_METHOD: (unitName: string) =>\n    `Checking aggregation method for ${unitName}`,\n  INITIALIZING_PLUGINS: 'Initializing plugins',\n  INITIALIZING_PLUGIN: (pluginName: string) =>\n    `Initializing \\`${pluginName}\\` instance`,\n  LOADING_PLUGIN_FROM_PATH: (pluginName: string, path: string) =>\n    `Loading ${pluginName} from ${path}`,\n  COMPUTING_PIPELINE_FOR_NODE: (nodeName: string) =>\n    `Running compute pipeline: \\`${nodeName}\\` plugin`,\n  COMPUTING_COMPONENT_PIPELINE: (component: string) =>\n    `**Computing \\`${component}\\` pipeline**`,\n  REGROUPING: 'Regrouping',\n  SKIPPING_REGROUP: 'Already correctly grouped - skipping regrouping.',\n  OBSERVING: (nodeName: string) =>\n    `Running observe pipeline: \\`${nodeName}\\` plugin`,\n  MERGING_DEFAULTS_WITH_INPUT_DATA: 'Merging defaults with input data',\n  AGGREGATING_OUTPUTS: 'Aggregating outputs',\n  AGGREGATING_NODE: (nodeName: string) => `Aggregating node ${nodeName}`,\n  PREPARING_OUTPUT_DATA: () => {\n    console.debug('\\n');\n    return 'Preparing output data';\n  },\n  EXPORTING_TO_YAML_FILE: (savepath: string) =>\n    `Exporting to yaml file: ${savepath}`,\n  EMPTY_PIPELINE: `You're using an old style manifest. Please update for phased execution. More information can be found here: \nhttps://if.greensoftware.foundation/major-concepts/imp-file`,\n  /** Exhaust messages */\n  OUTPUT_REQUIRED:\n    'Output path is required, please make sure output is configured properly.',\n  /** Plugins messages */\n  INVALID_NAME: '`name` config parameter is empty or contains all spaces',\n  START_LOWER_END: '`start-time` should be lower than `end-time`',\n  X_Y_EQUAL: 'The length of `x` and `y` should be equal',\n  ARRAY_LENGTH_NON_EMPTY:\n    'the length of the input arrays must be greater than 1',\n  WITHIN_THE_RANGE:\n    'The target x value must be within the range of the given x values',\n  MISSING_CSV_COLUMN: (columnName: string) =>\n    `There is no column with the name: ${columnName}.`,\n  NO_QUERY_DATA:\n    'One or more of the given query parameters are not found in the target CSV file column headers.',\n  INVALID_DATE_TYPE: (date: any) =>\n    `Unexpected date datatype: ${typeof date}: ${date}`,\n  INVALID_OBSERVATION_OVERLAP:\n    'Observation timestamps overlap, please check inputs.',\n  SCI_MISSING_FN_UNIT: (functionalUnit: string) =>\n    `'carbon' and ${functionalUnit} should be present in your input data.`,\n  MISSING_FUNCTIONAL_UNIT_CONFIG:\n    '`functional-unit` should be provided in your config',\n  MISSING_FUNCTIONAL_UNIT_INPUT:\n    '`functional-unit` value is missing from input data or it is not a positive integer',\n  REGEX_MISMATCH: (input: any, match: string) =>\n    `\\`${input}\\` does not match the ${match} regex expression`,\n  MISSING_MIN_MAX: 'Config is missing min or max value',\n  INVALID_MIN_MAX: (name: string) =>\n    `Min value should not be greater than or equal to max value of ${name}`,\n  FILE_FETCH_FAILED: (\n    filepath: string,\n    message: string\n  ) => `Failed fetching the file: ${filepath}.\n${message}`,\n  FILE_READ_FAILED: (\n    filepath: string,\n    error: string\n  ) => `Failed reading the file: ${filepath}. \n${error}`,\n  ZERO_DIVISION: (moduleName: string, index: number) =>\n    `-- SKIPPING -- DivisionByZero: you are attempting to divide by zero in ${moduleName} plugin : inputs[${index}]\\n`,\n  MISSING_CONFIG: 'Config is not provided.',\n  MISSING_INPUT_DATA: (param: string) =>\n    `${param} is missing from the input array, or has nullish value.`,\n  CONFIG_WARN: (plugins: string, isMore: boolean) => {\n    const withoutPlugins =\n      'You have included node-level config in your manifest. IF no longer supports node-level config. The manifest should be refactored to accept all its node-level config from config or input data.';\n    const withPlugins = `You have included node-level config in your manifest to support \\`${plugins}\\` plugin${\n      isMore ? 's' : ''\n    }. IF no longer supports node-level config. \\`${plugins}\\` plugin${\n      isMore ? 's' : ''\n    } should be refactored to accept all its config from config or input data.`;\n\n    return plugins.length ? withPlugins : withoutPlugins;\n  },\n};\n"]}