theprogrammablemind 7.12.3 → 7.12.4-beta.0

package/client.js

@@ -89,12 +89,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'
@@ -196,7 +196,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 +638,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) }
@@ -775,6 +777,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)
@@ -1153,6 +1156,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 +1192,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) {
@@ -1464,6 +1488,7 @@ const knowledgeModuleImpl = async ({
   errorHandler = defaultErrorHandler,
   process: processResults = defaultProcess,
   stopAtFirstFailure = true,
+  acceptsAdditionalConfig = false,
   ...rest
 } = {}) => {
   /*
@@ -1843,34 +1868,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 +1909,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 +1995,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 ************************`)
                 }
               }
             }
@@ -2072,11 +2101,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 +2166,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.0",
   "license": "UNLICENSED"
 }

package/src/config.js

@@ -1742,6 +1742,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 +2259,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 +2758,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