theprogrammablemind 8.0.0-beta.21 → 8.0.0-beta.22

package/client.js

@@ -237,9 +237,8 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
   config.setArgs(args)
 }
 
-const gs = (g) => (contexts, separator, lastSeparator) => {
+const gs = (g) => async (contexts, separator, lastSeparator) => {
   if (!Array.isArray(contexts)) {
-    debugger
     throw new Error('Expected a list')
   }
 
@@ -253,7 +252,7 @@ const gs = (g) => (contexts, separator, lastSeparator) => {
   let nextSeparator = ''
   for (let i = 0; i < contexts.length; ++i) {
     const context = contexts[i]
-    const value = g(context)
+    const value = await g(context)
     if (i > 0) {
       if (i === contexts.length - 1) {
         nextSeparator = lastSeparator
@@ -290,12 +289,12 @@ const analyzeMetaData = (right, wrong) => {
   return []
 }
 
-const processContexts = (contexts, params) => {
+const processContexts = async (contexts, params) => {
   const contextsPrime = []
   const generated = []
   const logs = []
   for (const context of contexts) {
-    const result = processContext(context, Object.assign({}, params, { logs }))
+    const result = await processContext(context, Object.assign({}, params, { logs }))
     contextsPrime.push(result.context)
     generated.push(result.generated)
   }
@@ -311,7 +310,7 @@ const getObjects = (objects) => {
   }
 }
 
-const processContext = (context, { objects = {}, config, logs = [] }) => {
+const processContext = async (context, { objects = {}, config, logs = [] }) => {
   const generators = config.getGenerators(logs)
   const semantics = config.getSemantics(logs)
 
@@ -329,10 +328,10 @@ const processContext = (context, { objects = {}, config, logs = [] }) => {
   const args = { objects, response, getObjects: getObjects(objects) }
   setupArgs(args, config, logs, hierarchy)
 
-  context = semantics.apply(args, context)
-  const generated = generators.apply(args, context)
+  context = await semantics.apply(args, context)
+  const generated = await generators.apply(args, context)
   const assumed = { paraphrase: true, response: false, isResponse: false }
-  const paraphrases = generators.apply({ ...args, assumed }, context, { paraphrase: true, response: false, isResponse: false })
+  const paraphrases = await generators.apply({ ...args, assumed }, context, { paraphrase: true, response: false, isResponse: false })
   let responses = []
   if (context.isResponse) {
     responses = generated
@@ -480,7 +479,7 @@ const processContextsB = async ({ config, hierarchy, semantics, generators, json
       if (!config.get('skipSemantics')) {
         const semantics = config.getSemantics(json.logs)
         try {
-          contextPrime = semantics.apply(args, context)
+          contextPrime = await semantics.apply(args, context)
         } catch (e) {
           if (e.message == 'Maximum call stack size exceeded') {
             const mostCalled = semantics.getMostCalled()
@@ -490,7 +489,7 @@ const processContextsB = async ({ config, hierarchy, semantics, generators, json
           if (isInstance) {
             console.log('error', e.error)
           }
-          contextPrime = semantics.apply(args, {
+          contextPrime = await semantics.apply(args, {
             marker: 'error',
             context,
             text: e ? e.toString() : 'not available',
@@ -506,11 +505,11 @@ const processContextsB = async ({ config, hierarchy, semantics, generators, json
         continue
       }
       let assumed = { isResponse: true }
-      const generated = contextPrime.isResponse ? config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed) : ''
+      const generated = contextPrime.isResponse ? await config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed) : ''
       let generatedParenthesized = []
       if (generateParenthesized) {
         config.parenthesized = true
-        generatedParenthesized = contextPrime.isResponse ? config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed) : ''
+        generatedParenthesized = contextPrime.isResponse ? await config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed) : ''
         config.parenthesized = false
       }
       // assumed = { paraphrase: true, response: false };
@@ -518,11 +517,11 @@ const processContextsB = async ({ config, hierarchy, semantics, generators, json
       if (generateParenthesized) {
         config.parenthesized = false
       }
-      const paraphrases = config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed)
+      const paraphrases = await config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed)
       let paraphrasesParenthesized = []
       if (generateParenthesized) {
         config.parenthesized = true
-        paraphrasesParenthesized = config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed)
+        paraphrasesParenthesized = await config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed)
         config.parenthesized = false
       }
       contextsPrime.push(contextPrime)
@@ -668,7 +667,7 @@ const loadInstance = async (config, instance) => {
 
       const uuid = config.nameToUUID(instance.name)
       setupArgs(args, config, config.logs, hierarchy, uuid)
-      results.apply(args)
+      await results.apply(args)
     } else {
       if (results.skipSemantics) {
         config.config.skipSemantics = results.skipSemantics

package/package.json

@@ -64,6 +64,6 @@
     "sort-json": "^2.0.0",
     "uuid": "^8.3.2"
   },
-  "version": "8.0.0-beta.21",
+  "version": "8.0.0-beta.22",
   "license": "UNLICENSED"
 }

package/src/config.js

@@ -352,7 +352,7 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
 
         const generator = {
           where: bridge.generatorp.where || bridge.where || client.where(4),
-          match: (args) => bridge.id == args.context.marker && args.context.level == level && args.context.paraphrase && match(args),
+          match: async (args) => bridge.id == args.context.marker && args.context.level == level && args.context.paraphrase && await match(args),
           apply: (args) => apply(args),
           applyWrapped: apply,
           property: 'generatorp'
@@ -369,7 +369,7 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
         const level = bridge.generatorr.level >= 0 ? bridge.generatorr.level : bridge.level + 1
         const generator = {
           where: bridge.generatorr.where || bridge.where || client.where(4),
-          match: (args) => bridge.id == args.context.marker && args.context.level == level && !args.context.paraphrase && (args.context.response || args.context.isResponse) && match(args),
+          match: async (args) => bridge.id == args.context.marker && args.context.level == level && !args.context.paraphrase && (args.context.response || args.context.isResponse) && await match(args),
           apply: (args) => apply(args),
           applyWrapped: apply,
           property: 'generatorr'
@@ -1005,8 +1005,8 @@ class Config {
     return instance
   }
   */
-  getEvaluator (s, calls, log, context) {
-    const instance = s({ ...context, evaluate: true })
+  async getEvaluator (s, calls, log, context) {
+    const instance = await s({ ...context, evaluate: true })
     calls.touch(instance)
     if (!instance.evalue && !instance.verbatim && !instance.value) {
       this.warningNotEvaluated(log, context)
@@ -1023,7 +1023,7 @@ class Config {
   fragmentInstantiator (contexts) {
     return new Object({
       contexts: () => contexts,
-      instantiate: (mappings) => {
+      instantiate: async (mappings) => {
         const instantiated = _.cloneDeep(contexts)
         // const todo = [...instantiated]
         // const todo = [...instantiated]
@@ -1031,8 +1031,8 @@ class Config {
         while (todo.length > 0) {
           const context = todo.pop()
           for (const mapping of mappings) {
-            if (mapping.match({ context })) {
-              mapping.apply({ context })
+            if (await mapping.match({ context })) {
+              await mapping.apply({ context })
             }
           }
           for (const key of Object.keys(context)) {
@@ -1618,8 +1618,8 @@ class Config {
     return params
   }
 
-  processContext (context) {
-    return client.processContext(context, this.getParams())
+  async processContext (context) {
+    return await client.processContext(context, this.getParams())
   }
 
   process (query, options) {

package/src/generators.js

@@ -44,7 +44,7 @@ class Generator {
     return `Generator(${this.match}, ${this._applyWrapped || this._apply})${this.property ? `\nsee the ${this.property} property` : ''}`
   }
 
-  matches (baseArgs, objects, context, hierarchy, config, options = {}) {
+  async matches (baseArgs, objects, context, hierarchy, config, options = {}) {
     if (objects && objects.namespaced) {
       objects = objects.namespaced[this.uuid]
     }
@@ -63,17 +63,17 @@ class Generator {
     }
     const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
     // return this.match(args)
-    const matches = this.match(args)
+    const matches = await this.match(args)
     if ((matches && (options.debug || {}).match) ||
         callId == this.callId) {
       debugger // next line is the matcher
-      this.match(args)
+      await this.match(args)
     }
     return matches
   }
 
   // apply (baseArgs, objects, g, gs, context, hierarchy, config, response, log, options = {}) {
-  apply (baseArgs, objects, context, hierarchy, config, response, log, options = {}) {
+  async apply (baseArgs, objects, context, hierarchy, config, response, log, options = {}) {
     if (!log) {
       throw new Error('generators.apply argument log is required')
     }
@@ -129,7 +129,7 @@ class Generator {
         callId == this.callId) {
       debugger
     }
-    return this._apply(args)
+    return await this._apply(args)
   }
 }
 
@@ -165,7 +165,7 @@ class Generators {
   };
 
   // assumed - properties added to context before the generators are called. For setting paraphrase property
-  apply (args, context, assumed = {}, options = {}) {
+  async apply (args, context, assumed = {}, options = {}) {
     if (Array.isArray(context)) {
       throw new Error('Expected a context not an array')
     }
@@ -186,12 +186,12 @@ class Generators {
     const stack = args.calls.push()
     for (let igenerator = 0; igenerator < this.generators.length; ++igenerator) {
       const generator = this.generators[igenerator]
-      if (generator.matches(args, objects, context, hierarchy, config, options)) {
+      if (await generator.matches(args, objects, context, hierarchy, config, options)) {
         const log = (message) => { this.logs.push(message) }
         // this.logs.push(`Generators: applied ${generator.toString()}\n to\n ${JSON.stringify(context)}`)
         let errorMessage = 'The apply function did not return a value'
         try {
-          generated = generator.apply(args, objects, context, hierarchy, config, response, log)
+          generated = await generator.apply(args, objects, context, hierarchy, config, response, log)
         } catch (e) {
           // the next if handle this
           generated = null

package/src/semantics.js

@@ -49,7 +49,7 @@ class Semantic {
     }
   }
 
-  matches (baseArgs, context, options = {}) {
+  async matches (baseArgs, context, options = {}) {
     const hierarchy = baseArgs.hierarchy
     const config = baseArgs.config
 
@@ -71,16 +71,16 @@ class Semantic {
     }
     const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
 
-    const matches = this.matcher(args)
+    const matches = await this.matcher(args)
     if (matches && (options.debug || {}).match ||
         callId == this.callId) {
       debugger // next line is the matcher
-      this.matcher(args)
+      await this.matcher(args)
     }
     return matches
   }
 
-  apply (baseArgs, context, s, log, options = {}) {
+  async apply (baseArgs, context, s, log, options = {}) {
     const { hierarchy, config, response } = baseArgs
     const objects = baseArgs.getObjects(this.uuid)
     if (config && config.debugLoops) {
@@ -124,7 +124,7 @@ class Semantic {
     if (args.breakOnSemantics) {
       debugger
     }
-    this._apply(args)
+    await this._apply(args)
     return contextPrime
   }
 }
@@ -176,7 +176,7 @@ class Semantics {
     return this.semantics[maxOrdinal]
   }
 
-  applyToContext (args, context, options) {
+  async applyToContext (args, context, options) {
     // let context_prime = {}
     if (!(context instanceof Array || context instanceof Object)) {
       return context
@@ -197,14 +197,14 @@ class Semantics {
       if (semantic.isQuestion && seenQuestion) {
         continue
       }
-      if (semantic.matches(args, context, options)) {
+      if (await semantic.matches(args, context, options)) {
         if (!this.calls[counter]) {
           this.calls[counter] = 0
         }
         this.calls[counter] += 1
         const log = (message) => { this.logs.push(message) }
         try {
-          contextPrime = semantic.apply(args, context, s, log, options)
+          contextPrime = await semantic.apply(args, context, s, log, options)
           if (!contextPrime.controlKeepMotivation && semantic.oneShot) {
             // semantic.tied_ids.forEach((tied_id) => args.config.removeSemantic(tied_id))
             args.config.removeSemantic(semantic)
@@ -310,19 +310,19 @@ class Semantics {
     return contextPrime
   }
 
-  applyToContexts (args, contexts, options) {
+  async applyToContexts (args, contexts, options) {
     const contextsPrime = []
     for (const context of contexts) {
-      contextsPrime.push(this.applyToContext(args, context, options))
+      contextsPrime.push(await this.applyToContext(args, context, options))
     }
     return contextsPrime
   }
 
-  apply (args, context, options) {
+  async apply (args, context, options) {
     if (Array.isArray(context)) {
-      return this.applyToContexts(args, context, options)
+      return await this.applyToContexts(args, context, options)
     } else if (context instanceof Object) {
-      return this.applyToContext(args, context, options)
+      return await this.applyToContext(args, context, options)
     } else {
       return context
     }