theprogrammablemind_4wp 7.12.3 → 7.12.4-beta.1

package/client.js

@@ -14,8 +14,17 @@ const { appendNoDups, InitCalls, updateQueries, safeNoDups } = require('./src/he
 const runtime = require('./runtime')
 const sortJson = runtime.sortJson
 
-const getConfig_getObjectsCheck = (testConfig) => {
-  return (testConfig.checks && testConfig.checks.objects) || []
+const getConfig_getObjectsCheck = (config, testConfig) => {
+  let testConfigName = config.name
+  if (testConfig.testModuleName) {
+    testConfigName = testConfig.testModuleName
+  }
+  const checks = (testConfig.checks && testConfig.checks.objects) || []
+  if (Array.isArray(checks)) {
+    return { [testConfigName]: checks }
+  } else {
+    return checks
+  }
 }
 
 const getConfig_getContextCheck = (testConfig) => {
@@ -26,8 +35,24 @@ const pickContext = (testConfig) => (context) => {
   return project(context, getConfig_getContextCheck(testConfig))
 }
 
-const pickObjects = (testConfig, objects) => {
-  return project(objects, getConfig_getObjectsCheck(testConfig))
+const pickObjects = (config, testConfig, getObjects) => {
+  /*
+  let testConfigName = config.name
+  if (testConfig.testModuleName) {
+    objects = getObjects(config.config.objects)(config.getConfigs()[testConfig.testModuleName].uuid)
+    testConfigName = testConfig.testModuleName
+  }
+  */
+  const checks = getConfig_getObjectsCheck(config, testConfig)
+  const projection = {}
+  for (let km in checks) {
+    const objects = getObjects(km)
+    if (!objects) {
+      throw new Error(`In the checks for ${config.name} the KM ${km} does not exist`)
+    }
+    projection[km] = project(objects, checks[km])
+  }
+  return projection
 }
 
 // move ask to the KM's since verbatim is called
@@ -89,12 +114,12 @@ const sameJSON = (json1, json2) => {
   return JSON.stringify(sjson1) == JSON.stringify(sjson2)
 }
 
-const vimdiff = (actualJSON, expectedJSON) => {
+const vimdiff = (actualJSON, expectedJSON, title) => {
   const path = '.'
   const actual = sortJson(actualJSON, { depth: 25 })
-  runtime.fs.writeFileSync(`${path}/actual.json`, JSON.stringify(actual, 0, 2))
+  runtime.fs.writeFileSync(`${path}/actual.json`, JSON.stringify({ title, actual}, 0, 2))
   const expected = sortJson(expectedJSON, { depth: 25 })
-  runtime.fs.writeFileSync(`${path}/expected.json`, JSON.stringify(expected, 0, 2))
+  runtime.fs.writeFileSync(`${path}/expected.json`, JSON.stringify({ title, expected}, 0, 2))
   // console.log(`vimdiff ${path}/actual.json ${path}/expected.json`)
   {
     const editor = runtime.process.env.EDITOR || 'vimdiff'
@@ -105,6 +130,9 @@ const vimdiff = (actualJSON, expectedJSON) => {
 }
 
 const listable = (hierarchy) => (c, type) => {
+  if (!c) {
+    return false
+  }
   if (hierarchy.isA(c.marker, type)) {
     return true
   }
@@ -119,6 +147,9 @@ const listable = (hierarchy) => (c, type) => {
 }
 
 const isA = (hierarchy) => (child, parent) => {
+  if (!child || !parent) {
+    return false
+  }
   if (child.marker) {
     child = child.marker
   }
@@ -148,6 +179,7 @@ class ErrorReason extends Error {
 
 const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
   config.setArgs(args)
+  // callId
   args.calls = new InitCalls(args.isInstance ? `${args.isInstance}#${config.name}` : config.name)
   if (global.theprogrammablemind && global.theprogrammablemind.loadForTesting) {
     args.calls = new InitCalls(Object.keys(global.theprogrammablemind.loadForTesting)[0])
@@ -196,7 +228,7 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
 
   args.addAssumedScoped = (args, assumed) => {
     const addAssumed = (args, ...moreAssumed) => {
-      return { ...args, assumed: Object.assign({}, (args.assumed || {}), ...moreAssumed) }
+      return { ...args, assumed: Object.assign({}, assumed, (args.assumed || {}), ...moreAssumed) }
     }
 
     args.s = (c) => config.getSemantics(logs).apply(args, c)
@@ -638,7 +670,9 @@ const loadInstance = (config, instance) => {
       // config.addInternal(results, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false)
       // config.addInternal(config.template.queries[i], { handleCalculatedProps: true } )
       const uuid = config.nameToUUID(instance.name)
-      config.addInternal(_.cloneDeep(instance.template.queries[i]), { uuid, addFirst: true, handleCalculatedProps: true })
+      // used to do a CLONE
+      // config.addInternal(_.cloneDeep(instance.template.queries[i]), { uuid, addFirst: true, handleCalculatedProps: true })
+      config.addInternal(instance.template.queries[i], { uuid, addFirst: true, handleCalculatedProps: true })
     } else if (results.apply) {
       const objects = config.get('objects')
       const args = { objects, getObjects: getObjects(objects) }
@@ -655,10 +689,8 @@ const loadInstance = (config, instance) => {
         config.config.skipSemantics = results.skipSemantics
       }
       const args = { config, hierarchy, json: results, commandLineArgs: {} }
-      if (instance.queries) {
-        args.isInstance = `instance${i}`
-        args.instance = instance.queries[i]
-      }
+      args.isInstance = `instance${i}`
+      args.instance = ''
       processContextsB(args)
       if (results.skipSemantics) {
         config.config.skipSemantics = null
@@ -775,6 +807,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
         response.trace = response.trace.concat(json.trace)
         response.version = json.version
         response.explain_priorities = json.explain_priorities
+        response.contextual_priorities_ambiguities = json.contextual_priorities_ambiguities
 
         response.contexts = response.contexts.concat(contextsPrime)
         response.generated = response.generated.concat(generatedPrime)
@@ -849,11 +882,6 @@ const runTest = async (config, expected, { args, verbose, testConfig, debug }) =
   }
 
   let objects = getObjects(config.config.objects)(config.uuid)
-  let testConfigName = config.name
-  if (testConfig.testModuleName) {
-    objects = getObjects(config.config.objects)(config.getConfigs()[testConfig.testModuleName].uuid)
-    testConfigName = testConfig.testModuleName
-  }
   try {
     const result = await _process(config, test, { errorHandler, isTest: true })
     result.query = test
@@ -893,7 +921,7 @@ const runTest = async (config, expected, { args, verbose, testConfig, debug }) =
       }
       return expected.objects.namespaced[expected.objects.nameToUUID[name]] || {}
     }
-    const expected_checked = sortJson(pickObjects(testConfig, expectedGetObjects(testConfigName)), { depth: 25 })
+    const expected_checked = sortJson(pickObjects(config, testConfig, expectedGetObjects), { depth: 25 })
     const actualGetObjects = (name) => {
       if (!name) {
         name = config.name
@@ -901,7 +929,7 @@ const runTest = async (config, expected, { args, verbose, testConfig, debug }) =
       const km = config.configs.find((km) => km.name == name)
       return config.config.objects.namespaced[km.uuid] || {}
     }
-    const actual_checked = sortJson(pickObjects(testConfig, actualGetObjects(testConfigName)), { depth: 25 })
+    const actual_checked = sortJson(pickObjects(config, testConfig, actualGetObjects), { depth: 25 })
     const failed_checked = !matching(actual_objects, expected_objects)
 
     const failed_checks = !matching(actual_objects, expected_objects)
@@ -1153,6 +1181,24 @@ const defaultErrorHandler = async (error) => {
   throw error
 }
 
+const printContextualPrioritiesAmbiguities = (cpa) => {
+  console.log('Contextual Priorities Ambiguities')
+  for (const counter in cpa) {
+    console.log(`  Counter ${counter}`)
+    for (const choices of cpa[counter]) {
+      console.log('     [')
+        for (const choice of choices) {
+          console.log('        [')
+          for (const element of choice) {
+            console.log(`          ${JSON.stringify(element)},`)
+          }
+          console.log('        ],')
+        }
+      console.log('     ],')
+    }
+  }
+}
+
 const defaultInnerProcess = (config, errorHandler, responses) => {
   if (responses.errors) {
     console.log('Errors')
@@ -1171,6 +1217,9 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
     console.log('Logs')
     responses.logs.forEach((log) => console.log(`    ${log}`))
   }
+  if (responses.contextual_priorities_ambiguities) {
+    printContextualPrioritiesAmbiguities(responses.contextual_priorities_ambiguities)
+  }
   console.log(responses.trace)
 
   if (global.beforeObjects) {
@@ -1209,8 +1258,15 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
       console.log(`    inputs: ${JSON.stringify(inputs)} output: ${JSON.stringify(output)}  reason: ${reason}`)
     }
   }
-  const objects = config.get('objects').namespaced[config.uuid]
-  const picked = sortJson(pickObjects(config.testConfig, objects), { depth: 25 })
+  // const objects = config.get('objects').namespaced[config.uuid]
+  const actualGetObjects = (name) => {
+    if (!name) {
+      name = config.name
+    }
+    const km = config.configs.find((km) => km.name == name)
+    return config.config.objects.namespaced[km.uuid] || {}
+  }
+  const picked = sortJson(pickObjects(config, config.testConfig, actualGetObjects), { depth: 25 })
   if (!_.isEmpty(picked)) {
     console.log('--- Object showing only the checked values ---')
     console.log(JSON.stringify(picked, null, 2))
@@ -1464,6 +1520,7 @@ const knowledgeModuleImpl = async ({
   errorHandler = defaultErrorHandler,
   process: processResults = defaultProcess,
   stopAtFirstFailure = true,
+  acceptsAdditionalConfig = false,
   ...rest
 } = {}) => {
   /*
@@ -1843,34 +1900,33 @@ const knowledgeModuleImpl = async ({
             if (results.length > 0) {
               let headerShown = false
 
-              let errorCount = 0
+              let hasError = false
               for (const result of results) {
-                let hasError = false
                 if (JSON.stringify(result.expected.paraphrases) !== JSON.stringify(result.actual.paraphrases)) {
-                  hasError = true
+                  result.hasError = true
                 }
                 if (!args.testNoParenthesized) {
                   if (JSON.stringify(result.expected.paraphrasesParenthesized) !== JSON.stringify(result.actual.paraphrasesParenthesized)) {
-                    hasError = true
+                    result.hasError = true
                   }
                   if (JSON.stringify(result.expected.generatedParenthesized) !== JSON.stringify(result.actual.generatedParenthesized)) {
-                    hasError = true
+                    result.hasError = true
                   }
                 }
                 if (JSON.stringify(result.expected.responses) !== JSON.stringify(result.actual.responses)) {
-                  hasError = true
+                  result.hasError = true
                 }
                 if (JSON.stringify(result.expected.checked) !== JSON.stringify(result.actual.checked)) {
-                  hasError = true
+                  result.hasError = true
                 }
                 if (!sameJSON(result.expected.checkedContexts, result.actual.checkedContexts)) {
-                  hasError = true
+                  result.hasError = true
                 }
-                if (hasError) {
-                  errorCount += 1
+                if (result.hasError) {
+                  hasError = true
                 }
               }
-              const hasError = errorCount > 0
+
               if (hasError) {
                 console.log('**************************** ERRORS ************************')
                 for (const result of results) {
@@ -1885,21 +1941,20 @@ const knowledgeModuleImpl = async ({
                       newError = true
                       headerShown = true
                       if (args.vimdiff) {
-                        vimdiff(result.actual.paraphrasesParenthesized, result.expected.paraphrasesParenthesized)
+                        vimdiff(actual, expected, `"${result.utterance}" - ${label}`)
                       }
-                      errorCount += 1
+                      result.hasError = true
                     }
                   }
                   show('paraphrases', result.expected.paraphrases, result.actual.paraphrases)
                   if (!args.testNoParenthesized) {
                     show('paraphrases parenthesized', result.expected.paraphrasesParenthesized, result.actual.paraphrasesParenthesized)
                   }
-                  /*
-                  }
                   show('responses', result.expected.responses, result.actual.responses)
                   if (!args.testNoParenthesized) {
                     show('responses parenthesized', result.expected.generatedParenthesized, result.actual.generatedParenthesized)
                   }
+                  /*
                   if (JSON.stringify(result.expected.paraphrases) !== JSON.stringify(result.actual.paraphrases)) {
                     if (!headerShown) {
                       console.log('  Failure')
@@ -1972,7 +2027,13 @@ const knowledgeModuleImpl = async ({
                 if (!(useTestConfig.check && useTestConfig.check.length > 0)) {
                   console.log('use -v arg to write files expected.json and actual.json in the current directory for detailed comparison. Or do -s and then git diff the changes.')
                   // console.log(JSON.stringify(contexts))
-                  console.log(`**************************** THERE WERE ${errorCount} ERRORS ************************`)
+                  let errorCount = 0
+                  for (const result of results) {
+                    if (result.hasError) {
+                      errorCount += 1
+                    }
+                  }
+                  console.log(`**************************** THERE WERE ${errorCount} TEST FAILURES ************************`)
                 }
               }
             }
@@ -2017,6 +2078,13 @@ const knowledgeModuleImpl = async ({
       })
       f()
     } else if (args.query) {
+      let useTestConfig = testConfig
+      if (args.testModuleName) {
+        config.testConfig.testModuleName = args.testModuleName
+        config.testConfig.checks = config.getConfigs()[args.testModuleName].getTestConfig().checks
+        // useTestConfig = config.getConfigs()[args.testModuleName].getTestConfig()
+        // useTestConfig.testModuleName = args.testModuleName
+      }
       const objects = getObjects(config.config.objects)(config.uuid)
       // for the compare
       if (args.objectDiff) {
@@ -2072,11 +2140,16 @@ const knowledgeModuleImpl = async ({
       }
     }
 
-    createConfigExport = () => {
+    createConfigExport = (additionalConfig) => {
       if (createConfig.cached) {
         return createConfig.cached
       }
-      const config = createConfig()
+      const config = createConfig(acceptsAdditionalConfig ? additionalConfig : null)
+      if (!acceptsAdditionalConfig && additionalConfig) {
+        config.stop_auto_rebuild()
+        additionalConfig(config)
+        config.restart_auto_rebuild()
+      }
       initConfig(config)
       // config.rebuild({ isModule: true })
       createConfig.cached = config
@@ -2132,7 +2205,10 @@ function w (func) {
 }
 
 const knowledgeModule = async (...args) => {
-  await knowledgeModuleImpl(...args).catch((e) => console.error(e))
+  await knowledgeModuleImpl(...args).catch((e) => {
+    console.error(e)
+    process.exit(-1)
+  })
 }
 
 module.exports = {

package/package.json

@@ -65,6 +65,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.12.3",
+  "version": "7.12.4-beta.1",
   "license": "UNLICENSED"
 }

package/src/config.js

@@ -199,7 +199,7 @@ const priority_valid = (cp) => {
   )
 }
 
-const handleBridgeProps = (config, bridge, addFirst) => {
+const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
   ecatch(`While processing the bridge for ${bridge.id}#${bridge.level}`,
     () => {
       if (!bridge.bridge) {
@@ -260,7 +260,8 @@ const handleBridgeProps = (config, bridge, addFirst) => {
       }
       */
 
-      const addUUID = (obj) => { return { ...obj, uuid: config.uuid } }
+      const addUUID = (obj) => { return { ...obj, uuid: uuid || config.uuid } }
+
       if (bridge.generators) {
         const generators = [...bridge.generators]
         generators.reverse()
@@ -343,14 +344,14 @@ const handleBridgeProps = (config, bridge, addFirst) => {
   )
 }
 
-const handleCalculatedProps = (baseConfig, moreConfig, addFirst) => {
+const handleCalculatedProps = (baseConfig, moreConfig, { addFirst, uuid } = {}) => {
   if (moreConfig.bridges) {
     moreConfig.bridges = moreConfig.bridges.map((bridge) => {
       bridge = { ...bridge }
       const valid = ['after', 'before', 'bridge', 'development', 'evaluator', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
         'level', 'optional', 'selector', 'semantic', 'words', /Bridge$/, 'localHierarchy', 'levelSpecificHierarchy', 'where', 'uuid']
       helpers.validProps(valid, bridge, 'bridge')
-      handleBridgeProps(baseConfig, bridge, addFirst)
+      handleBridgeProps(baseConfig, bridge, { addFirst, uuid })
       return bridge
     })
   }
@@ -1314,7 +1315,7 @@ class Config {
     if (global.transitoryMode) {
       def.transitoryMode = true
     }
-    handleBridgeProps(this, def)
+    handleBridgeProps(this, def, { uuid })
     bridges.push(def)
     this.checkBridges()
     this._delta.json.bridges.push({ action: 'add', bridge: def })
@@ -1742,6 +1743,15 @@ class Config {
     this.addedArgss.push(moreArgs)
   }
 
+  stop_auto_rebuild() {
+    this._stop_auto_rebuild = true
+  }
+
+  restart_auto_rebuild() {
+    this._stop_auto_rebuild = false
+    this.rebuild()
+  }
+
   getAddedArgs (args) {
     for (let addedArgs of this.addedArgss) {
       addedArgs = addedArgs(args)
@@ -2250,6 +2260,9 @@ class Config {
 
   // rebuild ({ isModule: mainIsModule = false } = {}) {
   rebuild ({ isModule: mainIsModule } = {}) {
+    if (this._stop_auto_rebuild) {
+      return
+    }
     this.resetDelta()
     const debug = this.config.debug
     this.config = _.cloneDeep(this.initConfig)
@@ -2746,63 +2759,70 @@ class Config {
     }
   }
 
-  add (more) {
-    if (more === this) {
-      throw new Error('Cannot add an object to itself.')
-    }
-    if (!(more instanceof Config)) {
-      more = new Config(more)
-    }
+  add (...mores) {
+    mores.forEach((km) => {
+      if (km === this) {
+        throw new Error('Cannot add an object to itself.')
+      }
+    })
 
-    this.valid()
-    more.valid()
-    // copy so i don't have to copy later
-    more = more.copy()
-    more.server(this._server, this._key, this._queryParams)
-
-    this.loadOrder.addList(more.configs.map((km) => km.name || km.uuid))
-
-    // get the new ones
-    // remove the dups
-    // run the initialize one all new ones
-    // this.configs = this.configs.concat(new KM({config: more}));
-    // only set for the first one the rest have it set
-    const namespace = this._namespace.concat(more._namespace)
-    const moreKMs1 = [new KM({ config: more, getCounter: (name) => this.getCounter(name), uuid: more.uuid, namespace })]
-    const moreKMs2 = more.configs.slice(1).map((km) => {
+    mores = mores.map((km) => {
+      if (!(km instanceof Config)) {
+        km = new Config(km)
+      }
       return km
-      // const cp = km.copy()
-      // cp.namespace = namespace
-      // return cp;
     })
-    const moreKMs = moreKMs1.concat(moreKMs2)
-    const eqClass = moreKMs.map((km) => km.uuid)
-    this._eqClasses.push(eqClass)
-    // look for dups and combine them with the eqclasses
-    for (const moreKM of moreKMs) {
-      const existingKM = this.configs.find((km) => moreKM._name && km.name === moreKM.name)
-      if (existingKM) {
-        this.addEqClass(existingKM, moreKM)
-      } else {
-        this.configs.push(moreKM)
+
+    mores.forEach((more) => {
+      this.valid()
+      more.valid()
+      // copy so i don't have to copy later
+      more = more.copy()
+      more.server(this._server, this._key, this._queryParams)
+
+      this.loadOrder.addList(more.configs.map((km) => km.name || km.uuid))
+
+      // get the new ones
+      // remove the dups
+      // run the initialize one all new ones
+      // this.configs = this.configs.concat(new KM({config: more}));
+      // only set for the first one the rest have it set
+      const namespace = this._namespace.concat(more._namespace)
+      const moreKMs1 = [new KM({ config: more, getCounter: (name) => this.getCounter(name), uuid: more.uuid, namespace })]
+      const moreKMs2 = more.configs.slice(1).map((km) => {
+        return km
+        // const cp = km.copy()
+        // cp.namespace = namespace
+        // return cp;
+      })
+      const moreKMs = moreKMs1.concat(moreKMs2)
+      const eqClass = moreKMs.map((km) => km.uuid)
+      this._eqClasses.push(eqClass)
+      // look for dups and combine them with the eqclasses
+      for (const moreKM of moreKMs) {
+        const existingKM = this.configs.find((km) => moreKM._name && km.name === moreKM.name)
+        if (existingKM) {
+          this.addEqClass(existingKM, moreKM)
+        } else {
+          this.configs.push(moreKM)
+        }
       }
-    }
-    more.resetToOne()
-    this.config.eqClasses = this._eqClasses
-    // greg
-    // setup instances
-    this.instances = []
-    this.configs.forEach((km) => {
-      this.instances = (km._config.instances || this.initInstances.slice()).concat(this.instances)
-    })
-    const noDups = []
-    for (const instance of this.instances) {
-      if (!noDups.find((existing) => existing.name == instance.name)) {
-        noDups.push(instance)
+      more.resetToOne()
+      this.config.eqClasses = this._eqClasses
+      // greg
+      // setup instances
+      this.instances = []
+      this.configs.forEach((km) => {
+        this.instances = (km._config.instances || this.initInstances.slice()).concat(this.instances)
+      })
+      const noDups = []
+      for (const instance of this.instances) {
+        if (!noDups.find((existing) => existing.name == instance.name)) {
+          noDups.push(instance)
+        }
       }
-    }
-    this.instances = noDups
-
+      this.instances = noDups
+    })
     this.rebuild()
     this.valid()
     return this
@@ -2823,7 +2843,7 @@ class Config {
     debugConfigProps(more)
 
     if (hcps) {
-      handleCalculatedProps(this, more, addFirst)
+      handleCalculatedProps(this, more, { addFirst, uuid })
       applyUUID(more, uuid || this._uuid)
     }
     for (const key of Object.keys(more)) {