theprogrammablemind_4wp 7.5.8-beta.68 → 7.5.8-beta.69

package/client.js

@@ -2,6 +2,7 @@ const { Semantics, Semantic } = require('./src/semantics')
 const { Generators, Generator } = require('./src/generators')
 const DigraphInternal = require('./src/digraph_internal')
 const Digraph = require('./src/digraph')
+const { project } = require('./src/project')
 const fetch = require('node-fetch')
 const base64 = require('base-64')
 const deepEqual = require('deep-equal')
@@ -22,11 +23,7 @@ const getConfig_getContextCheck = (testConfig) => {
 }
 
 const pickContext = (testConfig) => (context) => {
-  const picked = {}
-  for (let prop of getConfig_getContextCheck(testConfig)) {
-    picked[prop] = context[prop]
-  }
-  return sortJson(picked, { depth: 25 })
+  return project(context, getConfig_getContextCheck(testConfig))
 }
 
 const getAsk = (config) => (uuid) => (asks) => {
@@ -384,7 +381,7 @@ const setupContexts = (rawContexts) => {
   return contexts
 }
 
-const processContextsB = ({ config, hierarchy, semantics, generators, json, isTest, isInstance, query, data, retries, url, commandLineArgs }) => {
+const processContextsB = ({ config, hierarchy, semantics, generators, json, isTest, isInstance, instance, query, data, retries, url, commandLineArgs }) => {
   // TODO fix this name to contextsPrime
   const contextsPrime = []
   const generatedPrime = []
@@ -395,7 +392,7 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
   const contexts = setupContexts(json.contexts)
 
   const objects = config.get('objects')
-  const args = { objects, isResponse: true, response: json, isTest, isInstance, getObjects: getObjects(objects), isInstance }
+  const args = { objects, isResponse: true, response: json, isTest, isInstance, getObjects: getObjects(objects), instance }
   if (!json.logs) {
     json.logs = []
   }
@@ -406,28 +403,6 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
   config.debugLoops = commandLineArgs && commandLineArgs.debugLoops
   while (toDo.length > 0) {
     const context = toDo.shift()
-    /*
-    if (false && query) {
-      if (config.wasChanged()) {
-        // process contexts that overlap
-        overlap = lastRange
-      } else {
-        config.watch()
-      }
-      if (overlap) {
-        if (overlaps(overlap, context)) {
-          // okay
-          query = query.slice(overlap.end+1)
-          data.utterance = query
-          const json = await doWithRetries(retries, url, data)
-          toDo = setupContexts(json.contexts).slice(1) // take off the start context
-        }
-        overlap = undefined
-      }
-      lastRange = context.range
-    }
-    */
-
     args.calls.next()
     let contextPrime = context
     context.topLevel = true
@@ -446,6 +421,9 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
             e.message += `\nThe most called semantic was:\nnotes: ${mostCalled.notes}\nmatch: ${mostCalled.matcher.toString()}\napply: ${mostCalled._apply.toString()}\n`
           }
           // contextPrime = semantics.apply(args, { marker: 'error', context, error: e })
+          if (isInstance) {
+            console.log('error', e.error)
+          }
           contextPrime = semantics.apply(args, { marker: 'error', context, reason: e.reason })
         }
       }
@@ -605,7 +583,7 @@ const loadInstance = (config, instance) => {
       // config.addInternal(config.template.queries[i], { handleCalculatedProps: true } )
       config.addInternal(instance.template.queries[i], { addFirst: true, handleCalculatedProps: true } )
     } else {
-      processContextsB({ config, hierarchy, json: results/*, generators, semantics */, commandLineArgs: {}, isInstance: `instance${i}` })
+      processContextsB({ config, hierarchy, json: results/*, generators, semantics */, commandLineArgs: {}, isInstance: `instance${i}`, instance: instance.queries[i] })
     }
   }
   global.transitoryMode = transitoryMode
@@ -632,7 +610,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
 
   let { data, /* generators, semantics, */ hierarchy } = setupProcessB({ config, initializer, allowDelta: true })
   if (commandLineArgs && commandLineArgs.checkForLoop) {
-    data.checkForLoop = true
+    data.checkForLoop = commandLineArgs.checkForLoop
   }
   if (rebuildingTemplate) {
     data.errors_ignore_contextual_priorities_non_existant_ops = true
@@ -702,6 +680,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
         response.times += json.times
         response.trace = response.trace.concat(json.trace)
         response.version = json.version
+        response.explain_priorities = json.explain_priorities
 
         response.contexts = response.contexts.concat(contextsPrime)
         response.generated = response.generated.concat(generatedPrime)
@@ -1170,6 +1149,12 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
     return picked
   }
 
+  if (responses.explain_priorities) {
+    console.log("Explain Priorities")
+    for ([inputss, outpus, reason] of responses.explain_priorities) {
+      console.log(`    ${JSON.stringify(inputss)} reason: ${reason}`)
+    }
+  }
   const picked = pickEm()
   if (!_.isEmpty(picked)) {
     console.log('--- checked object properties ---')
@@ -1438,7 +1423,7 @@ const knowledgeModule = async ({
     parser.add_argument('-i', '--info', { action: 'store_true', help: 'Print meta-data for the module' })
     parser.add_argument('-v', '--vimdiff', { action: 'store_true', help: 'For failures run vimdiff' })
     parser.add_argument('-g', '--greg', { action: 'store_true', help: 'Set the server to be localhost so I can debug stuff' })
-    parser.add_argument('-cl', '--checkForLoop', { action: 'store_true', help: 'Check for loops in the priorities' })
+    parser.add_argument('-cl', '--checkForLoop', { nargs: "?", help: 'Check for loops in the priorities, Optional argument is list of operator keys to consider. For example [["banana", 0], ["food", 1]]' })
     parser.add_argument('-r', '--retrain', { action: 'store_true', help: 'Get the server to retrain the neural nets' })
     parser.add_argument('-q', '--query', { help: 'Run the specified query' })
     parser.add_argument('-ip ', '--server', { help: 'Server to run against' })
@@ -1451,15 +1436,16 @@ const knowledgeModule = async ({
     parser.add_argument('-p', '--print', { help: 'Print the specified elements c === config, w === words, b === bridges, o === operators d === objects (d for data), h === hierarchy, g === generators, s === semantics, l === load t=tests ordering p === priorities a == associations j == JSON sent to server. for example --print wb' })
     parser.add_argument('-s', '--save', { action: 'store_true', help: 'When running with the --query flag this will save the current run to the test file. When running without the --query flag all tests will be run and resaved.' })
     parser.add_argument('-sd', '--saveDeveloper', { action: 'store_true', help: 'Same as -s but the query will not show up in the info command.' })
-    parser.add_argument('-dic', '--debugIncludeConvolutions', { action: 'store_true', help: 'When running with the --debugIncludeConvolutions flag the logs will include convolutions which are somewhat annoying verbose. Default is false' })
     parser.add_argument('-dl', '--debugLoops', { action: 'store_true', help: 'When running with the --debugLoops flag the logs calls to semantics and generators will be immediately written to the console '})
     parser.add_argument('-d', '--debug', { action: 'store_true', help: 'When running with the --debug flag this set the debug flag in the config' })
-    parser.add_argument('-da', '--debugAssociation', { help: helpDebugAssociation })
-    parser.add_argument('-dh', '--debugHierarchy', { help: helpDebugHierarchy })
-    parser.add_argument('-dp', '--debugPriority', { help: helpDebugPriority })
-    parser.add_argument('-dcp', '--debugContextualPriority', { help: helpDebugContextualPriority })
-    parser.add_argument('-db', '--debugBridge', { help: helpDebugBridge })
-    parser.add_argument('-do', '--debugOperator', { help: helpDebugOperator })
+    parser.add_argument('-da', '--debugAssociation', { action: 'store_true', help: helpDebugAssociation })
+    parser.add_argument('-dh', '--debugHierarchy', { action: 'store_true', help: helpDebugHierarchy })
+    parser.add_argument('-dp', '--debugPriority', { action: 'store_true', help: helpDebugPriority })
+    parser.add_argument('-dcp', '--debugContextualPriority', { action: 'store_true', help: helpDebugContextualPriority })
+    parser.add_argument('-db', '--debugBridge', { action: 'store_true', help: helpDebugBridge })
+    parser.add_argument('-do', '--debugOperator', { action: 'store_true', help: helpDebugOperator })
+    parser.add_argument('-ep', '--explainPriorities', { action: 'store_true', help: "The server will return all priorities including the generated one along with an explanation of there they came from"})
+    parser.add_argument('-dic', '--debugIncludeConvolutions', { nargs: "?", help: 'When running with the --debugIncludeConvolutions flag the logs will include convolutions which are somewhat annoyingly verbose. Default is false' })
 
     const args = parser.parse_args()
     args.count = args.count || 1
@@ -1467,7 +1453,35 @@ const knowledgeModule = async ({
     if (args.parenthesized) {
       config.parenthesized = true
     }
-
+    if (args.checkForLoop) {
+      try {
+        args.checkForLoop = JSON.parse(args.checkForLoop)
+        const isKey = (what) => {
+          if (!Array.isArray(what)) {
+            return false
+          }
+          if (what.length !== 2) {
+            return false
+          }
+          if (!typeof what[0] == 'string') {
+            return false
+          }
+          if (!typeof what[1] == 'number') {
+            return false
+          }
+          return true
+        }
+        if (!Array.isArray(args.checkForLoop) || args.checkForLoop.some((value) => !isKey(value))) {
+          throw new Error(`Error for the checkForLoop argument. Expected a JSON array of operator keys of the form "[<id>, <level>]"`)
+        }
+      } catch( e ) {
+        throw new Error(`Error parsing JSON of the checkForLoop argument. ${e}`)
+      }
+    } else {
+      if (process.argv.includes('--checkForLoop') || process.argv.includes('-cl')) {
+        args.checkForLoop = true
+      }
+    }
     if (args.debugAssociation) {
       console.log(helpDebugAssociation)
       runtime.process.exit(-1)
@@ -1525,7 +1539,12 @@ const knowledgeModule = async ({
     if (args.debug) {
       config.config.debug = true
     }
-    config.config.debugIncludeConvolutions = args.debugIncludeConvolutions
+
+    if (args.explainPriorities) {
+      config.config.explain_priorities = true
+    }
+
+    config.config.debugIncludeConvolutions = args.debugIncludeConvolutions || process.argv.includes('--debugIncludeConvolutions') || process.argv.includes('-dic') 
 
     if (template) {
       const needsRebuild = config.needsRebuild(template.template, template.instance, options)

package/package.json

@@ -64,6 +64,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.5.8-beta.68",
+  "version": "7.5.8-beta.69",
   "license": "ISC"
 }

package/src/config.js

@@ -30,6 +30,72 @@ const config_toServer = (config) => {
   }
 }
 
+const debugPriority = (priority) => {
+  if (global.entodictonDebugPriority) {
+    if (helpers.safeEquals(entodictonDebugPriority, priority)) {
+      debugger; // debug hierarchy hit
+    }
+  }
+}
+
+const debugAssociation = (association) => {
+  if (global.entodictonDebugAssociation) {
+    if (helpers.safeEquals(global.entodictonDebugAssociation, association)) {
+      debugger; // debug association hit
+    }
+  }
+}
+
+const debugContextualPriority = (contextual_priority) => {
+  if (global.entodictonDebugContextualPriority) {
+    if (helpers.safeEquals(entodictonDebugContextualPriority, contextual_priorities)) {
+      debugger; // debug hierarchy hit
+    }
+  }
+}
+
+const debugHierarchy = (pair) => {
+  if (global.entodictonDebugHierarchy) {
+    if (helpers.safeEquals(global.entodictonDebugHierarchy, pair)) {
+      debugger; // debug hierarchy hit
+    }
+  }
+}
+
+const debugBridge = (bridge) => { 
+  if (global.entodictonDebugBridge) {
+    if (global.entodictonDebugBridge[0] == bridge.id && global.entodictonDebugBridge[1] == bridge.level) {
+      debugger; // debug hierarchy hit
+    }
+  }
+}
+
+const debugOperator = (operator) => {
+  if (global.entodictonDebugOperator) {
+    if ((operator.pattern || operator) === global.entodictonDebugOperator) {
+      debugger; // debug operator hit
+    }
+  }
+}
+
+const debugConfigProps = (config) => {
+  const checkProps = [
+    { property: 'priorities', check: (v) => debugPriority(v) },
+    { property: 'association', check: (v) => debugAssociation(v) },
+    { property: 'contextual_priorities', check: (v) => debugContextualPriority(v) },
+    { property: 'hierarchy', check: (v) => debugHierarchy(v) },
+    { property: 'operators', check: (v) => debugOperator(v) },
+    { property: 'bridges', check: (v) => debugBridge(v) },
+  ]
+  for (const { property, check } of checkProps) {
+    if (config[property]) {
+      for (const value of config[property]) {
+        check(value)
+      }
+    }
+  }
+}
+
 const validConfigProps = (config) => {
   const valid = [ 
     'hierarchy', 
@@ -188,7 +254,7 @@ const handleBridgeProps = (config, bridge, addFirst) => {
           if (typeof after == 'string') {
             after = [after, 0]
           }
-          config.addPriorities([after, [bridge.id, bridge.level]])
+          config.addPriorities([[bridge.id, bridge.level], after])
         }
       }
       if (bridge.after) {
@@ -196,7 +262,7 @@ const handleBridgeProps = (config, bridge, addFirst) => {
           if (typeof before == 'string') {
             before = [before, 0]
           }
-          config.addPriorities([[bridge.id, bridge.level], before])
+          config.addPriorities([before, [bridge.id, bridge.level]])
         }
       }
       if (bridge.words) {
@@ -1046,6 +1112,9 @@ class Config {
     }
   }
 
+  debugConfig() {
+  }
+
   addAssociation (association) {
     if (!this.config.associations) {
       this.config.associations = {
@@ -1053,25 +1122,18 @@ class Config {
         positive: []
       }
     }
-    if (global.entodictonDebugAssociation) {
-      if (helpers.safeEquals(global.entodictonDebugAssociation, association)) {
-        debugger; // debug association hit
-      }
-    }
+    debugAssociation(association)
     this.config.associations.positive.push(association)
     this._delta.json.associations.push({ action: 'add', association })
   }
 
   // TODO add more error checking to these like addHierarchy has
+  // TODO change name from priorities to priority
   addPriorities (priorities) {
     if (!this.config.priorities) {
       this.config.priorities = []
     }
-    if (global.entodictonDebugPriority) {
-      if (helpers.safeEquals(entodictonDebugPriority, priorities)) {
-        debugger; // debug hierarchy hit
-      }
-    }
+    debugPriority(priorities)
     this.config.priorities.push(priorities)
     this._delta.json.priorities.push({ action: 'add', priorities })
   }
@@ -1081,11 +1143,7 @@ class Config {
     if (!this.config.contextual_priorities) {
       this.config.contextual_priorities = []
     }
-    if (global.entodictonDebugContextualPriority) {
-      if (helpers.safeEquals(entodictonDebugContextualPriority, contextual_priorities)) {
-        debugger; // debug hierarchy hit
-      }
-    }
+    debugContextualPriority(contextual_priority)
     contextual_priority_valid(contextual_priority)
     this.config.contextual_priorities.push(contextual_priority)
     const cpServer = contextual_priorities_toServer(contextual_priority)
@@ -1109,11 +1167,7 @@ class Config {
     if (typeof parent !== 'string') {
       throw new Error(`addHierarchy expected parent property to be a string. got ${JSON.stringify(parent)}`)
     }
-    if (global.entodictonDebugHierarchy) {
-      if (helpers.safeEquals(entodictonDebugHierarchy, [child, parent])) {
-        debugger; // debug hierarchy hit
-      }
-    }
+    debugHierarchy([child, parent])
     this.config.hierarchy.push(edge)
     // TODO greg11 this.hierarchy.addEdge(edge)
     this._delta.json.hierarchy.push([child, parent])
@@ -1126,13 +1180,7 @@ class Config {
     if (typeof parent !== 'string') {
       throw new Error(`addHierarchy expected parent to be a string. got ${JSON.stringify(parent)}`)
     }
-
-    if (global.entodictonDebugHierarchy) {
-      if (helpers.safeEquals(global.entodictonDebugHierarchy, [child, parent])) {
-        debugger; // debug hierarchy hit
-      }
-    }
-
+    debugHierarchy([child, parent])
     if (this.config.hierarchy.find( (element) => {
       const hc = hierarchyCanonical(element) 
       if (child == hc.child && parent == hc.parent) {
@@ -1161,13 +1209,8 @@ class Config {
     }
     const bridges = this.config.bridges
     const def = Object.assign({}, bridge, { uuid: uuid || this._uuid })
-  
-    if (global.entodictonDebugBridge) {
-      if (global.entodictonDebugBridge[0] == bridge.id && global.entodictonDebugBridge[1] == bridge.level) {
-        debugger; // debug hierarchy hit
-      }
-    }
-
+ 
+    debugBridge(bridge)
     if (bridge.allowDups) {
       if (bridges.find( (b) => b.id == bridge.id && b.level == bridge.level && b.bridge == bridge.bridge )) {
         return;
@@ -1247,11 +1290,7 @@ class Config {
       operator = Object.assign({}, objectOrPattern, { uuid: uuid || this._uuid })
     }
 
-    if (global.entodictonDebugOperator) {
-      if (operator.pattern === global.entodictonDebugOperator) {
-        debugger; // debug operator hit
-      }
-    }
+    debugOperator(operator)
 
     if (operator.allowDups) {
       if (operators.find( (o) => o.pattern == operator.pattern )) {
@@ -2722,6 +2761,8 @@ class Config {
         more = _.cloneDeep(more.initConfig)
       }
     }
+    debugConfigProps(more)
+
     if (hcps) {
       handleCalculatedProps(this, more, addFirst)
       applyUUID(more, this._uuid)
@@ -2818,6 +2859,7 @@ class Config {
             }
           }
         }
+
         // console.log('key', key, 'XXX')
         // console.log('more', JSON.stringify(more, null, 2))
         if (addFirst) {

package/src/project.js

@@ -1,12 +1,32 @@
 
 const project = (object, filter) => {
+  if (!object) {
+    return
+  }
+
   let projection = {}
   if (Array.isArray(filter)) {
     if (Array.isArray(object)) {
       return object.map( element => project(element, filter) )
     } else {
-      for (const property of filter) {
-        projection[property] = object[property]
+      for (let properties of filter) {
+        if (typeof properties == 'object') {
+          debugger
+          const subfilterProperty = Object.keys(properties)[0]
+          oldValue = object[subfilterProperty]
+          if (Array.isArray(oldValue)) {
+            projection[subfilterProperty] = oldValue.map((v) => project(v, properties[subfilterProperty]))
+          } else {
+            projection[subfilterProperty] = project(oldValue, properties[subfilterProperty])
+          }
+        } else {
+          if (!Array.isArray(properties)) {
+            properties = [properties]
+          }
+          for (const property of properties) {
+            projection[property] = object[property]
+          }
+        }
       }
     }
   } else if (typeof filter == 'object') {