theprogrammablemind_4wp 7.4.3 → 7.5.0-beta.1

package/client.js

@@ -692,10 +692,23 @@ const runTest = async (config, expected, { verbose, afterTest, testConfig, debug
       const failed_responses = !matching(result.responses, expected.responses)
       const failed_contexts = !matching(result.contexts, expected.contexts)
       const failed_objects = !matching(actual_objects, expected_objects)
+
+      const pickEm = (objects) => {
+        const picked = {}
+        for (let prop of (testConfig.check || [])) {
+          picked[prop] = objects[prop]
+        }
+        return picked
+      }
+      const expected_checked = sortJson(pickEm(expected.objects.namespaced[0]), { depth: 25 })
+      const actual_checked = sortJson(pickEm(objects), { depth: 25 })
+      const failed_checked = !matching(actual_objects, expected_objects)
+
+      const failed_checks = !matching(actual_objects, expected_objects)
       const actual_config = sortJson(convertToStable(getConfigForTest(config, testConfig)), { depth: 25 })
       const expected_config = sortJson(convertToStable(expected.config), { depth: 25 })
       const failed_config = !matching(actual_config, expected_config)
-      let failed = failed_paraphrases || failed_responses || failed_contexts || failed_objects || failed_config
+      let failed = failed_paraphrases || failed_responses || failed_contexts || failed_objects || failed_config || failed_checked
       if (!failed) {
         if (config.afterTest) {
           failed = config.afterTest({ query: test, expected, actual: result, config })
@@ -703,8 +716,8 @@ const runTest = async (config, expected, { verbose, afterTest, testConfig, debug
             return {
               utterance: test,
               errorFromAfterTest: failed,
-              expected: { responses: expected.responses, paraphrases: expected.paraphrases, results: expected.contexts, objects: expected_objects, config: expected.config },
-              actual: { responses: result.responses, paraphrases: result.paraphrases, results: result.contexts, objects: actual_objects, config: actual_config }
+              expected: { responses: expected.responses, paraphrases: expected.paraphrases, results: expected.contexts, checked: expected_checked, objects: expected_objects, config: expected.config },
+              actual: { responses: result.responses, paraphrases: result.paraphrases, results: result.contexts, checked: actual_checked, objects: actual_objects, config: actual_config }
             }
           }
         }
@@ -720,8 +733,8 @@ const runTest = async (config, expected, { verbose, afterTest, testConfig, debug
       if (failed) {
         return {
           utterance: test,
-          expected: { responses: expected.responses, paraphrases: expected.paraphrases, results: expected.contexts, objects: expected_objects, config: expected.config },
-          actual: { responses: result.responses, paraphrases: result.paraphrases, results: result.contexts, objects: actual_objects, config: actual_config }
+          expected: { responses: expected.responses, paraphrases: expected.paraphrases, results: expected.contexts, checked: expected_checked, objects: expected_objects, config: expected.config },
+          actual: { responses: result.responses, paraphrases: result.paraphrases, results: result.contexts, checked: actual_checked, objects: actual_objects, config: actual_config }
         }
       }
     } catch(error) {
@@ -1254,7 +1267,7 @@ const knowledgeModule = async ({
     parser.add_argument('-q', '--query', { help: 'Run the specified query' })
     parser.add_argument('-ip ', '--server', { help: 'Server to run against' })
     parser.add_argument('-qp ', '--queryParams', { help: 'Query params for the server call' })
-    parser.add_argument('-qd', '--queryDelete', { help: 'Delete the specified query from the tests file' })
+    parser.add_argument('-td', '--testDelete', { help: 'Delete the specified query from the tests file.' })
     parser.add_argument('-c', '--clean', { help: 'Remove data from the test files. a === association' })
     parser.add_argument('-od', '--objectDiff', { action: 'store_true', help: 'When showing the objects use a colour diff' })
     parser.add_argument('-daa', '--dontAddAssociations', { action: 'store_true', help: 'Do not add associations from the tests.' })
@@ -1293,11 +1306,11 @@ const knowledgeModule = async ({
       return
     }
 
-    if (args.queryDelete) {
+    if (args.testDelete) {
       let tests = JSON.parse(runtime.fs.readFileSync(testConfig.name))
-      tests = tests.filter( (test) => test.query !== args.queryDelete );
+      tests = tests.filter( (test) => test.query !== args.testDelete );
       writeTestFile(testConfig.name, tests)
-      console.log(`Remove the test for "${args.queryDelete}"`)
+      console.log(`Remove the test for "${args.testDelete}"`)
       return
     }
 
@@ -1462,34 +1475,63 @@ const knowledgeModule = async ({
             let newError = false
             if (results.length > 0) {
               let headerShown = false
-              console.log('**************************** ERRORS ************************')
+
+              let hasError = false
               for (const result of results) {
-                console.log('Utterance: ', result.utterance)
                 if (JSON.stringify(result.expected.paraphrases) !== JSON.stringify(result.actual.paraphrases)) {
-                  if (!headerShown) {
-                    console.log('  Failure')
-                  }
-                  console.log('    expected paraphrases', result.expected.paraphrases)
-                  console.log('    actual paraphrases  ', result.actual.paraphrases)
-                  newError = true
-                  headerShown = true
+                  hasError = true
                 }
                 if (JSON.stringify(result.expected.responses) !== JSON.stringify(result.actual.responses)) {
-                  if (!headerShown) {
-                    console.log('  Failure')
+                  hasError = true
+                }
+                if (JSON.stringify(result.expected.checked) !== JSON.stringify(result.actual.checked)) {
+                  hasError = true
+                }
+              }
+
+              if (hasError) {
+                console.log('**************************** ERRORS ************************')
+                for (const result of results) {
+                  console.log('Utterance: ', result.utterance)
+                  if (JSON.stringify(result.expected.paraphrases) !== JSON.stringify(result.actual.paraphrases)) {
+                    if (!headerShown) {
+                      console.log('  Failure')
+                    }
+                    console.log('    expected paraphrases', result.expected.paraphrases)
+                    console.log('    actual paraphrases  ', result.actual.paraphrases)
+                    newError = true
+                    headerShown = true
+                  }
+                  if (JSON.stringify(result.expected.responses) !== JSON.stringify(result.actual.responses)) {
+                    if (!headerShown) {
+                      console.log('  Failure')
+                    }
+                    console.log('    expected responses  ', result.expected.responses)
+                    console.log('    actual responses    ', result.actual.responses)
+                    newError = true
+                    headerShown = true
+                  }
+                  if (JSON.stringify(result.expected.checked) !== JSON.stringify(result.actual.checked)) {
+                    if (!headerShown) {
+                      console.log('  Failure')
+                    }
+                    console.log('    expected checked', result.expected.checked)
+                    console.log('    actual checked  ', result.actual.checked)
+                    newError = true
+                    headerShown = true
                   }
-                  console.log('    expected responses  ', result.expected.responses)
-                  console.log('    actual responses    ', result.actual.responses)
-                  newError = true
-                  headerShown = true
                 }
               }
               if (!headerShown) {
-                console.log('There are failures due to things other than paraphrases and response being different. They are not shown because you ran -tv or -tva which only shows difference in paraphrase and results. Usually what I do is -s and do a diff to make sure there are no other problems. If the paraphrases or results were different they would have shown here.')
+                if (!(testConfig.check && testConfig.check.length > 0)) {
+                  console.log('There are failures due to things other than paraphrases, responses and checked properties being different. They are not shown because you ran -tv or -tva which only shows difference in paraphrase and results. Usually what I do is -s and do a diff to make sure there are no other problems. If the paraphrases or results were different they would have shown here.')
+                }
+              }
+              if (!(testConfig.check && testConfig.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('**************************** ERRORS ************************')
               }
-              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('**************************** ERRORS ************************')
             }
             // const contexts = { failures: results }
             l(n - 1, hasError || newError)

package/package.json

@@ -61,6 +61,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.4.3",
+  "version": "7.5.0-beta.1",
   "license": "ISC"
 }

package/src/config.js

@@ -412,11 +412,11 @@ class Config {
   }
 
   getSemantics (logs = []) {
-    return new Semantics(this.config.semantics || [], logs)
+    return new Semantics(this.config.semantics || [], logs, { km: this.name })
   }
 
   getGenerators (logs = []) {
-    return new Generators(this.config.generators || [], logs)
+    return new Generators(this.config.generators || [], logs, { km: this.name })
   }
 
   warningNotEvaluated (log, value) {
@@ -979,6 +979,35 @@ class Config {
       throw 'Excepted the config argument to be a hash not a Config object'
     }
 
+    if (config) {
+      const valid = [ 
+        'hierarchy', 
+        'objects', 
+        'bridges', 
+        'operators', 
+        'words', 
+        'priorities', 
+        'associations', 
+        'name', 
+        'version', 
+        'generators', 
+        'semantics', 
+        'floaters', 
+        'debug',
+
+        // TODO Fix these from the test app
+        'implicit',
+        'expected_generated',
+        'expected_results',
+        'skipSemantics',
+        'description',
+        'contexts',
+        'utterances',
+        'flatten',
+      ]
+      helpers.validProps(valid, config, 'config')
+    }
+
     this.allowDelta = false
     this.resetDelta()
 
@@ -1030,7 +1059,8 @@ class Config {
     normalizeConfig(config)
 
     // set the default server so stuff just works
-    this.server('http://184.67.27.82:3000', '6804954f-e56d-471f-bbb8-08e3c54d9321')
+    // this.server('https://184.67.27.82:3000', '6804954f-e56d-471f-bbb8-08e3c54d9321')
+    this.server('https://thinktelligence.com:3000', '6804954f-e56d-471f-bbb8-08e3c54d9321')
 
     this.defaultConfig()
     this.initializerFn = ({ currentConfig }) => {
@@ -1063,6 +1093,9 @@ class Config {
         // this.config.words = {}
       }
       for (let bridge of (this.config.bridges || [])) {
+        const valid = [ 'before', 'bridge', 'development', 'evaluator', 'generatorp', 'generatorr', 'generators', 'id', 'inverted', 'isA',
+                        'level', 'optional', 'selector', 'semantic',  'words', /Bridge$/, 'localHierarchy' ]
+        helpers.validProps(valid, bridge, 'bridge')
         /*
         if (bridge.generator) {
           this.config.generators.push({ 
@@ -1078,13 +1111,16 @@ class Config {
         }
         if (bridge.before) {
           for (let after of bridge.before) {
+            if (typeof after == 'string') {
+              after = [after, 0]
+            }
             this.addPriorities([after, [bridge.id, bridge.level]])
           }
         }
         if (bridge.words) {
           for (let def of bridge.words) {
             if (typeof def == 'string') {
-              this.addWordInternal(def, {"id": bridge.id, "initial": "{}" })
+              this.addWordInternal(def, {"id": bridge.id, "initial": `{ value: "${def}"}` })
             } else {
               const word = def.word
               def = { initial: JSON.stringify(def), id: bridge.id, word: undefined }
@@ -1229,6 +1265,10 @@ class Config {
   }
 
   set api (value) {
+    if (!value.initialize) {
+      throw `Expected the API to have an initialize function for ${this.name}.`
+    }
+
     if (this._api && this._api.multiApi) {
       this._api.add(this, this._api, value)
     } else {
@@ -1746,7 +1786,8 @@ class Config {
       config.wasInitialized = false
       // TODO change name of config: to baseConfig:
       const kmFn = (name) => this.getConfig(name)
-      const args = { isModule, addWord: aw, km: kmFn, config, baseConfig: this, currentConfig: config, uuid: config._uuid, objects: namespacedObjects, namespace, api: config.api }
+      const hierarchy = new Digraph((config.config || {}).hierarchy || [])
+      const args = { isModule, addWord: aw, km: kmFn, hierarchy, config, baseConfig: this, currentConfig: config, uuid: config._uuid, objects: namespacedObjects, namespace, api: config.api }
       config.initializerFn(args)
       if (config.initAfterApi) {
         initAfterApis.push({ config, args })

package/src/digraph.js

@@ -9,21 +9,38 @@ const toA = (edge) => {
 class Digraph {
   // edges maybe either [child, parent] or { child, parent }
   constructor (edges = []) {
-    this.edges = edges
+    // dont make a copy of edges. this is shared and that breaks stuff. TODO fix this
+    this._edges = edges
   }
 
-  /*
-  edges () {
-    return this.edges
+  addEdges(edges) {
+    for (let edge of edges) {
+      this.addEdge(edge)
+    }
+  }
+
+  addEdge(edge) {
+    edge = toA(edge)
+    this._edges.push(edge)
+  }
+
+  get edges() {
+    return this._edges
+  }
+
+/*
+  set edges(edges) {
+    this._edges = edges.map( toA )
   }
 */
+
   acdcs (s, from, to) {
     const todo = [s]
     const seen = new Set([s])
     const acdcs = new Set([])
     while (todo.length > 0) {
       const n = todo.pop()
-      this.edges.forEach((e) => {
+      this._edges.forEach((e) => {
         e = toA(e)
         if (e[from] === n) {
           acdcs.add(e[to])
@@ -84,12 +101,12 @@ class Digraph {
   }
 
   add (child, parent) {
-    this.edges.push([child, parent])
+    this._edges.push([child, parent])
   }
 
   addList (l) {
     for (let i = 1; i < l.length; ++i) {
-      this.edges.push([l[i - 1], l[i]])
+      this._edges.push([l[i - 1], l[i]])
     }
   }
 

package/src/generators.js

@@ -124,12 +124,14 @@ class Generator {
 }
 
 class Generators {
-  constructor (generators, logs = []) {
+  constructor (generators, logs = [], options = {}) {
+    let index = -1
     generators = (generators || []).map((generator) => {
       if (generator instanceof Generator) {
         return generator
       } else {
-        return new Generator(generator)
+        index += 1
+        return new Generator({ km: options.km, index, ...normalizeGenerator(generator) })
       }
     })
     this.defaults = []

package/src/helpers.js

@@ -217,4 +217,35 @@ const sortJson = (json) => {
   return json
 }
 
-module.exports = { args, safeEquals, appendNoDups, hashIndexesGet, hashIndexesSet, translationMapping, normalizeGenerator, normalizeSemantic, isArray, isObject, isCompound, InitCalls, hashCode, sortJson }
+const validProps = (valids, object, type) => {
+  for (let prop of Object.keys(object)) {
+    let okay = false
+    for (valid of valids) {
+      if (prop.match(valid)) {
+        okay = true
+        break
+      }
+    }
+    if (!okay) {
+      throw `Unknown property "${prop}" in the ${type}. Valid properties are ${valid}. The ${type} is ${JSON.stringify(object)}`
+    }
+  }
+}
+
+module.exports = { 
+  validProps, 
+  args, 
+  safeEquals, 
+  appendNoDups, 
+  hashIndexesGet, 
+  hashIndexesSet, 
+  translationMapping, 
+  normalizeGenerator, 
+  normalizeSemantic, 
+  isArray, 
+  isObject, 
+  isCompound, 
+  InitCalls, 
+  hashCode, 
+  sortJson 
+}

package/src/semantics.js

@@ -115,12 +115,14 @@ class Semantic {
 }
 
 class Semantics {
-  constructor (semantics, logs = []) {
+  constructor (semantics, logs = [], options = {}) {
+    let index = -1
     semantics = semantics.map((semantic) => {
       if (semantic instanceof Semantic) {
         return semantic
       } else {
-        return new Semantic(semantic)
+        index += 1
+        return new Semantic({ km: options.km, index, ...normalizeSemantic(semantic) })
       }
     })