@hestia-earth/engine-models 0.73.1 → 0.73.3

package/src/config.ts

@@ -19,13 +19,17 @@ export interface IOrchestratorConfig {
   models: (IOrchestratorModelConfig | IOrchestratorModelConfig[])[];
 }
 
-const allowedTypes = [NodeType.Cycle, NodeType.Site, NodeType.ImpactAssessment];
-
 export type allowedType =
   | NodeType.Cycle
   | NodeType.Site
   | NodeType.ImpactAssessment;
 
+export const allowedTypes: allowedType[] = [
+  NodeType.Cycle,
+  NodeType.Site,
+  NodeType.ImpactAssessment
+];
+
 const validateType = (nodeType: any) =>
   allowedTypes.includes(nodeType) ||
   (() => {

package/src/index.ts

@@ -1,3 +1,5 @@
 export * from './config';
 export * from './models';
+export * from './utils';
+export * from './validate-config';
 export * from './version';

package/src/models.spec.ts

@@ -3,7 +3,7 @@ import { describe, expect, test } from '@jest/globals';
 import { models } from './models';
 
 describe('models', () => {
-  describe('loadModels', () => {
+  describe('models', () => {
     test('has links', () => {
       expect(models.links?.length > 0).toBeTruthy();
     });

package/src/models.ts

@@ -26,6 +26,10 @@ export interface IModel {
    * A key in the model if term does not exist.
    */
   modelKey?: string;
+  /**
+   * List of other models this model needs to run.
+   */
+  dependencies?: string[];
 }
 
 export type modelLookup = Record<

package/src/utils.spec.ts

@@ -0,0 +1,118 @@
+import { describe, expect, test } from '@jest/globals';
+
+import { IModel } from './models';
+import { findMatchingModel, findMatchingModelFromConfig } from './utils';
+
+describe('models', () => {
+  describe('findMatchingModel', () => {
+    const model = 'stehfestBouwman2006';
+    const term = 'noxToAirInorganicFertiliser';
+    const path =
+      'hestia_earth/models/stehfestBouwman2006/noxToAirInorganicFertiliser.py';
+
+    test('should find by model', () => {
+      const params = { model, term } as Partial<IModel>;
+
+      expect(findMatchingModel(params)).toEqual(
+        expect.objectContaining({ model, term, path })
+      );
+    });
+
+    test('should handle values with dot', () => {
+      expect(
+        findMatchingModel(
+          {
+            model: 'ipcc2019',
+            term: 'animal.pregnancyRateTotal'
+          },
+          { useDotValues: true }
+        )
+      ).toEqual(
+        expect.objectContaining({
+          model: 'ipcc2019',
+          term: 'pregnancyRateTotal'
+        })
+      );
+    });
+  });
+
+  describe('findMatchingModelFromConfig', () => {
+    test('should handle completeness', () => {
+      const model = 'cycle';
+
+      expect(
+        findMatchingModelFromConfig({
+          model,
+          value: 'completeness'
+        })
+      ).toEqual(
+        expect.objectContaining({
+          model: 'cycle',
+          modelKey: 'completeness.animalFeed'
+        })
+      );
+    });
+
+    test('should handle feedConversionRatio', () => {
+      const model = 'hestia';
+
+      expect(
+        findMatchingModelFromConfig({
+          model,
+          value: 'feedConversionRatio'
+        })
+      ).toEqual(
+        expect.objectContaining({
+          model: 'hestia',
+          term: 'feedConversionRatioCarbon'
+        })
+      );
+    });
+
+    test('should handle ecoinventV3AndEmberClimate', () => {
+      const model = 'ecoinventV3AndEmberClimate';
+
+      expect(
+        findMatchingModelFromConfig({
+          model,
+          value: 'all'
+        })
+      ).toEqual(
+        expect.objectContaining({
+          model
+        })
+      );
+    });
+
+    test('should handle ecoinventV3AndEmberClimate', () => {
+      const model = 'ecoinventV3AndEmberClimate';
+
+      expect(
+        findMatchingModelFromConfig({
+          model,
+          value: 'all'
+        })
+      ).toEqual(
+        expect.objectContaining({
+          model
+        })
+      );
+    });
+
+    test('should handle seed_emissions', () => {
+      const model = 'hestia';
+
+      expect(
+        findMatchingModelFromConfig({
+          model,
+          value: 'seed_emissions'
+        })
+      ).toEqual(
+        expect.objectContaining({
+          model,
+          modelKey: 'seed_emissions'
+        })
+      );
+    });
+  });
+});

package/src/utils.ts

@@ -0,0 +1,67 @@
+import { IOrchestratorModelConfig } from './config';
+import { IModel, models } from './models';
+
+type findMatchFunc = (
+  model: IModel,
+  key: string,
+  value: string | string[]
+) => boolean;
+
+const matchWithDot: findMatchFunc = (model, key, value) =>
+  typeof value === 'string' && value.split('.').pop() === model[key];
+
+const matchPath: findMatchFunc = (model, key, value) =>
+  key === 'path' && typeof value === 'string' && model[key].startsWith(value);
+
+export const findMatchingModel = (
+  model: Partial<IModel>,
+  config: {
+    useDotValues?: boolean;
+  } = {
+    useDotValues: false
+  }
+): IModel =>
+  Object.keys(model).length > 0
+    ? models.links.find((m) =>
+        Object.entries(model).every(
+          ([key, value]) =>
+            value === m[key] ||
+            (config.useDotValues && matchWithDot(m, key, value)) ||
+            matchPath(m, key, value)
+        )
+      )
+    : null;
+
+const modelMatchOrder = ({
+  model,
+  value
+}: Pick<IOrchestratorModelConfig, 'model' | 'value'>) =>
+  [
+    { model, term: value },
+    { model, modelKey: value },
+    {
+      model,
+      modelKey: value.split('.').pop()
+    },
+    {
+      model,
+      term: value.split('.').pop()
+    },
+    {
+      model,
+      path: ['hestia_earth', 'models', model, value].join('/')
+    },
+    !value || value === 'all' ? { model } : null
+  ].filter(Boolean) as Partial<IModel>[];
+
+export const findMatchingModelFromConfig = (
+  model: Pick<IOrchestratorModelConfig, 'model' | 'value'>
+) =>
+  modelMatchOrder(model)
+    .map(
+      (params) =>
+        findMatchingModel(params) ||
+        findMatchingModel(params, { useDotValues: true })
+    )
+    ?.filter(Boolean)
+    ?.shift();

package/src/validate-config.spec.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from '@jest/globals';
+import { NodeType } from '@hestia-earth/schema';
+
+import { validateConfig } from './validate-config';
+
+describe('validate-config', () => {
+  describe('validateConfig', () => {
+    describe(NodeType.Cycle, () => {
+      test('should be valid', () => {
+        const results = validateConfig(NodeType.Cycle);
+        expect(results).toEqual([]);
+      });
+    });
+
+    describe(NodeType.ImpactAssessment, () => {
+      test('should be valid', () => {
+        const results = validateConfig(NodeType.ImpactAssessment);
+        expect(results).toEqual([]);
+      });
+    });
+
+    describe(NodeType.Site, () => {
+      test('should be valid', () => {
+        const results = validateConfig(NodeType.Site);
+        expect(results).toEqual([]);
+      });
+    });
+  });
+});

package/src/validate-config.ts

@@ -0,0 +1,67 @@
+import { allowedType, IOrchestratorModelConfig, loadConfig } from './config';
+import { findMatchingModelFromConfig } from './utils';
+
+// models not included in the links
+const skipModels = ['emissions.deleted', 'transformations'];
+
+const isHestiaResidueCyclicModel = ({
+  model,
+  value
+}: IOrchestratorModelConfig) =>
+  model === 'hestia' && value?.startsWith('residue');
+
+const isOrganicCarbonCyclicModel = ({
+  model,
+  value
+}: IOrchestratorModelConfig) =>
+  model === 'hestia' && value?.startsWith('organicCarbonPer');
+
+const includeModel = (model: IOrchestratorModelConfig) =>
+  [
+    !skipModels.includes(model.model),
+    // cyclic dependencies
+    !isHestiaResidueCyclicModel(model),
+    !isOrganicCarbonCyclicModel(model)
+  ].every(Boolean);
+
+// dependencies that cannot be validated
+const skipDependencies = [
+  // completeness gap-fills after other models run
+  'completeness'
+];
+
+const matchDependencies =
+  (models: IOrchestratorModelConfig[]) => (model: IOrchestratorModelConfig) => {
+    const { dependencies } = findMatchingModelFromConfig(model);
+    const previousModels = models.slice(0, models.indexOf(model));
+    const existing =
+      dependencies?.filter((value) =>
+        previousModels.some(
+          (config) => config.value?.split('.').pop() === value
+        )
+      ) ?? [];
+    return {
+      model,
+      existing,
+      missing:
+        dependencies
+          // skip dependencies that dont exist at all
+          ?.filter((value) => models.some((config) => config.value === value))
+          ?.filter(
+            (v) =>
+              !existing.includes(v) &&
+              !skipDependencies.includes(v) &&
+              v !== model.value
+          ) ?? []
+    };
+  };
+
+export const validateConfig = (nodeType: allowedType) => {
+  const config = loadConfig(nodeType);
+  // flatten all models to process one by one, starting with the last one
+  const models = config.models.flat();
+
+  const results = models.filter(includeModel).map(matchDependencies(models));
+
+  return results.filter((r) => r.missing.length > 0);
+};

package/src/version.ts

@@ -1 +1 @@
-export const ENGINE_VERSION = '0.73.1';
+export const ENGINE_VERSION = '0.73.3';