theprogrammablemind 7.5.8-beta.56 → 7.5.8-beta.58

package/client.js

@@ -126,6 +126,7 @@ const setupArgs = (args, config, logs, hierarchy) => {
   args.listable = listable(hierarchy)
   args.asList = asList
   args.retry = () => { throw new RetryError() }
+  args.fragments = (query) => config.fragment(query)
   const scopedAsk = getAsk(config)
 
   const getAPI = (uuid) => {
@@ -608,7 +609,6 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
     if (writeTests) {
       config.rebuild()
       const objects = getObjects(config.config.objects)(config.uuid)
-      config.beforeQuery({ query, isModule: false, objects })
     }
   } catch(error) {
     throw error
@@ -744,7 +744,7 @@ const getConfigForTest = (config, testConfig) => {
   return configForTest
 }
 
-const runTest = async (config, expected, { args, verbose, afterTest, testConfig, debug }) => {
+const runTest = async (config, expected, { args, verbose, testConfig, debug }) => {
   const test = expected.query
   // initialize in between test so state is not preserved since the test was adding without state
   config.rebuild()
@@ -769,7 +769,6 @@ const runTest = async (config, expected, { args, verbose, afterTest, testConfig,
     objects = getObjects(config.config.objects)(config.getConfigs()[testConfig.testModuleName].uuid)
     testConfigName = testConfig.testModuleName
   }
-  config.beforeQuery({ query: test, isModule: false, objects })
     try {
       const result = await _process(config, test, { errorHandler, isTest: true })
       result.query = test
@@ -844,37 +843,6 @@ const runTest = async (config, expected, { args, verbose, afterTest, testConfig,
       const expected_config = sortJson(convertToStable(expected.config), { depth: 25 })
       const failed_config = !matching(actual_config, expected_config)
       let failed = failed_paraphrases || failed_paraphrasesParenthesized || failed_generatedParenthesized || failed_responses || failed_contexts || failed_objects || failed_config || failed_checked
-      if (!failed) {
-        if (config.afterTest) {
-          failed = config.afterTest({ query: test, expected, actual: result, config })
-          if (failed) {
-            return {
-              utterance: test,
-              errorFromAfterTest: failed,
-              expected: { 
-                responses: expected.responses, 
-                paraphrases: expected.paraphrases, 
-                paraphrasesParenthesized: expected.paraphrasesParenthesized, 
-                generatedParenthesized: expected.generatedParenthesized, 
-                results: expected.contexts, 
-                checked: expected_checked, 
-                objects: expected_objects, 
-                config: expected.config 
-              },
-              actual: { 
-                responses: result.responses, 
-                paraphrases: result.paraphrases, 
-                paraphrasesParenthesized: result.paraphrasesParenthesized, 
-                generatedParenthesized: result.generatedParenthesized, 
-                results: result.contexts, 
-                checked: actual_checked, 
-                objects: actual_objects, 
-                config: actual_config 
-              }
-            }
-          }
-        }
-      }
 
       if (expected.metadata && result.metadata && failed) {
         const priorities = analyzeMetaData(expected.metadata, result.metadata)
@@ -942,19 +910,16 @@ const runTestsHelper = async (config, tests, failed, juicyBits) => {
 
 const runTests = async (config, testFile, juicyBits) => {
   const tests = JSON.parse(runtime.fs.readFileSync(testFile))
-  config.beforeTests()
   if (juicyBits.verbose) {
     console.log('\n', testFile, '-----------------------------------------------', '\n')
   }
   const v = await runTestsHelper(config, [...tests], [], juicyBits)
-  config.afterTests()
   return v
 }
 
 const saveTest = async (testFile, config, test, expected, testConfig, saveDeveloper) => {
   config.rebuild()
   const objects = getObjects(config.config.objects)(config.uuid)
-  config.beforeQuery({ query: test, isModule: false, objects })
   console.log(test)
   const result = await _process(config, test, { isTest: true })
   // const actualObjects = config.config.objects
@@ -1232,31 +1197,6 @@ const defaultProcess = ({ config, errorHandler }) => async (promise) => {
   }
 }
 
-/*
-const kmFileTemplate = (kmBaseName, kmName) =>
-`const entodicton = require('entodicton')
-const base = require('./${kmBaseName}').copy()
-const ${kmName}_tests = require('./${kmName}.test.json')
-const ${kmName}_instance = require('./${kmBaseName}.${kmName}.instance.json')
-
-const config = new entodicton.Config({ name: '${kmName}' })
-config.add(base)
-kirk_instance.base = '${kmBaseName}'
-config.load(${kmName}_instance)
-
-entodicton.knowledgeModule( {
-  module,
-  description: '${kmName} related concepts',
-  section,
-  config,
-  test: {
-          name: './${kmName}.test.json',
-          contents: ${kmName}_tests
-        },
-})
-`
-*/
-
 // loadTemplate BuiltTemplate
 const rebuildTemplate = async ({ config, target, template, errorHandler = defaultErrorHandler }) => {
   const accumulators = {
@@ -1393,18 +1333,15 @@ const knowledgeModule = async ({
   module: moduleFromJSFile,
   description,
   section,
-  config,
+  // config, createConfig,
+  createConfig,
+  newWay,
   demo,
   test,
   template,
   errorHandler = defaultErrorHandler,
   process: processResults = defaultProcess,
   stopAtFirstFailure = true,
-  beforeQuery = () => {},
-  beforeTests = () => {},
-  afterTests = () => {},
-  beforeTest = () => {},
-  afterTest = () => {},
   ...rest
 } = {}) => {
 
@@ -1413,22 +1350,14 @@ const knowledgeModule = async ({
     throw new Error(`Unknown arguments to knowledgeModule: ${unknownArgs.join()}`)
   }
 
-  config.beforeQuery = beforeQuery 
-  config.beforeTests = beforeTests 
-  config.afterTests = afterTests 
-  config.beforeTest = beforeTest 
-  config.afterTest = afterTest 
-
   const testConfig = test
 
   if (!moduleFromJSFile) {
     throw new Error("'module' is a required parameter. The value should be either 'module' or a lambda that will be called when the file is acting as a module.")
   }
-  if (!config) {
-    throw new Error("'config' is a required parameter. The value should the config that defines the knowledge module.")
-  }
-  if (!config.name) {
-    throw new Error("config must have 'name' set to the knowledge module name.")
+  // if (!config && !createConfig) {
+  if (!createConfig) {
+    throw new Error("'config' or 'createConfig' is a required parameter. The value should the config that defines the knowledge module.")
   }
   if (!description) {
     throw new Error("'description' is a required parameter. The value should the description of the knowledge module.")
@@ -1438,82 +1367,44 @@ const knowledgeModule = async ({
   }
 
   const isProcess = require.main === moduleFromJSFile
-  let loadForTesting = false
-  if (global.theprogrammablemind) {
-    if (global.theprogrammablemind.loadForTesting[config.name]) {
-      loadForTesting = true
+
+  const setupConfig = (config) => {
+    if (!config.name) {
+      throw new Error("config must have 'name' set to the knowledge module name.")
     }
-  }
 
-  // remove test only stuff
-  if (!isProcess && !loadForTesting) {
-    config.config.operators = config.config.operators.filter( (operator) => {
-      if (operator.development) {
-        return false
-      } else {
-        return true
-      }
-    })
-    config.config.bridges = config.config.bridges.filter( (bridge) => {
-      if (bridge.development) {
-        return false
-      } else {
-        return true
+    config.description = description
+    if (typeof test === 'object') {
+      if (test.contents) {
+        config.tests = test.contents
+        test = test.name
       }
-    })
-  }
-
-  let module
-  if (_.isFunction(moduleFromJSFile)) {
-    module = moduleFromJSFile
-  } else {
-    module = () => {
-      config.rebuild({ isModule: true })
-      moduleFromJSFile.exports = config
-    }
-  }
-  processResults = processResults({ config, errorHandler })
-  config.description = description
-  config.demo = demo
-  if (typeof test === 'object') {
-    if (test.contents) {
-      config.tests = test.contents
-      test = test.name
-    }
-  } else {
-    if (runtime.fs && runtime.fs.existsSync(test)) {
-      config.tests = JSON.parse(runtime.fs.readFileSync(test))
     } else {
-      config.tests = {}
-    }
-  }
-  config.setTestConfig(testConfig)
- 
-  if (!isProcess) {
-    if (template) {
-      if (config.needsRebuild(template.template, template.instance, { isModule: !isProcess })) {
-        const error = `This module "${config.name}" cannot be used because the instance file needs rebuilding. Run on the command line with no arguments or the -rt argument to rebuild.`
-        throw new Error(error)
-      }
-      try {
-        config.load(template.template, template.instance)
-      } catch( e ) {
-        errorHandler(e)
+      if (runtime.fs && runtime.fs.existsSync(test)) {
+        config.tests = JSON.parse(runtime.fs.readFileSync(test))
+      } else {
+        config.tests = {}
       }
     }
+    config.setTestConfig(testConfig)
   }
+
+
   if (isProcess) {
+    const config = createConfig()
+    setupConfig(config)
+    processResults = processResults({ config, errorHandler })
     // setup();
     const parser = new runtime.ArgumentParser({
       description: 'Entodicton knowledge module'
     })
 
-    const helpDebugAssociation = 'In order to get a debug break when a specific association is created set the DEBUG_ASSOCIATION environment variable to the JSON of the association to break on. For example DEBUG_ASSOCIATION=\'[["the", 0], ["mammal", 1]]\' })'
-    const helpDebugHierarchy = 'In order to get a debug break when a specific hierarchy is created set the DEBUG_HIERARCHY environment variable to the JSON of the child-parent pair to break on. For example DEBUG_HIERARCHY=\'[["cat", 1], ["mammel", 1]]\' })'
-    const helpDebugPriority = 'In order to get a debug break when a specific set of priorities is created set set DEBUG_PRIORITY environment variable to the JSON of the priorities that you want to break on. For example DEBUG_PRIORITY=\'[["verb", 0], ["article", 0]]\' })'
-    const helpDebugContextualPriority = 'In order to get a debug break when a specific set of contextual priorities is created set set DEBUG_CONTEXTUAL_PRIORITY environment variable to the JSON of the priorities that you want to break on. For example DEBUG_CONTEXTUAL_PRIORITY=\'{ context: [["verb", 0], ["article", 0], select: 1}\' })'
-    const helpDebugBridge = 'In order to get a debug break when a specific bridge is created set the DEBUG_BRIDGE environment variable to id/level to break on. For example DEBUG_BRIDGE=\'id#level\' })'
-    const helpDebugOperator = 'In order to get a debug break when a specific hierarcy is created set the DEBUG_OPERATOR environment variable to debug any config loaded. For example DEBUG_OPERATOR=\'([operator] ([arg]))\' })'
+    const helpDebugAssociation = 'In order to get a debug break when a specific association is created set the DEBUG_ASSOCIATION environment variable to the JSON of the association to break on. For example DEBUG_ASSOCIATION=\'[["the", 0], ["mammal", 1]]\''
+    const helpDebugHierarchy = 'In order to get a debug break when a specific hierarchy is created set the DEBUG_HIERARCHY environment variable to the JSON of the child-parent pair to break on. For example DEBUG_HIERARCHY=\'[["cat", 1], ["mammel", 1]]\''
+    const helpDebugPriority = 'In order to get a debug break when a specific set of priorities is created set set DEBUG_PRIORITY environment variable to the JSON of the priorities that you want to break on. For example DEBUG_PRIORITY=\'[["verb", 0], ["article", 0]]\''
+    const helpDebugContextualPriority = 'In order to get a debug break when a specific set of contextual priorities is created set set DEBUG_CONTEXTUAL_PRIORITY environment variable to the JSON of the priorities that you want to break on. For example DEBUG_CONTEXTUAL_PRIORITY=\'{ context: [["verb", 0], ["article", 0], select: 1}\''
+    const helpDebugBridge = 'In order to get a debug break when a specific bridge is created set the DEBUG_BRIDGE environment variable to id/level to break on. For example DEBUG_BRIDGE=\'id#level\''
+    const helpDebugOperator = 'In order to get a debug break when a specific hierarcy is created set the DEBUG_OPERATOR environment variable to debug any config loaded. For example DEBUG_OPERATOR=\'([operator] ([arg]))\''
 
 
     parser.add_argument('-tmn', '--testModuleName', { help: 'When running tests instead of using the current modules tests use the specified modules tests' })
@@ -1624,6 +1515,10 @@ const knowledgeModule = async ({
 
       }
       config.load(template.template, template.instance, { rebuild: needsRebuild })
+      if (config.name == 'ui') {
+        console.log('config.COUNTER', config.COUNTER)
+        debugger
+      }
       if (needsRebuild) {
         return
       }
@@ -1631,20 +1526,8 @@ const knowledgeModule = async ({
 
     if (!args.save && !args.rebuildTemplate && !args.dontAddAssociations) {
       config.addAssociationsFromTests(config.tests);
-      //for (let query in config.tests) {
-      //  config.addAssociations(config.tests[query].associations || []);
-      //}
     }
 
-    /*
-    if (args.buildTemplate) {
-      if (template) {
-        config.rebuild()
-        config.load(template.template, template.instance, { rebuild: true })
-      }
-    }
-    */
-
     let configPrinted = false
     const printConfig = () => {
       if (configPrinted) {
@@ -1892,7 +1775,6 @@ const knowledgeModule = async ({
         if (query.length === 0) {
           return readline.close()
         }
-        // const promise = processResults(_process(config, query, { testsFN: test }))
         const promise = _process(config, query, { testsFN: test }).then((results) => {
           console.log(results.responses.join(' '))
         })
@@ -1920,7 +1802,6 @@ const knowledgeModule = async ({
       if (args.objectDiff) {
         global.beforeObjects = _.cloneDeep(objects)
       }
-      config.beforeQuery({ query: args.query, isModule: false, objects })
       try {
         await processResults(_process(config, args.query, { commandLineArgs: args, dontAddAssociations: args.dontAddAssociations, writeTests: args.save || args.saveDeveloper, saveDeveloper: args.saveDeveloper, testConfig, testsFN: test }))
       } catch( error ) {
@@ -1929,11 +1810,55 @@ const knowledgeModule = async ({
     }
     printConfig()
   } else {
-    config.addAssociationsFromTests(config.tests);
-    //for (let query in config.tests) {
-    //  config.addAssociations(config.tests[query].associations || []);
-    //}
-    module()
+    const initConfig = (config) => {
+      setupConfig(config)
+
+      let loadForTesting = false
+      if (global.theprogrammablemind) {
+        if (global.theprogrammablemind.loadForTesting[config.name]) {
+          loadForTesting = true
+        }
+      }
+      // remove test only stuff
+      if (!isProcess && !loadForTesting) {
+        config.config.operators = config.config.operators.filter( (operator) => {
+          if (operator.development) {
+            return false
+          } else {
+            return true
+          }
+        })
+        config.config.bridges = config.config.bridges.filter( (bridge) => {
+          if (bridge.development) {
+            return false
+          } else {
+            return true
+          }
+        })
+      }
+
+      if (template) {
+        if (config.needsRebuild(template.template, template.instance, { isModule: !isProcess })) {
+          const error = `This module "${config.name}" cannot be used because the instance file needs rebuilding. Run on the command line with no arguments or the -rt argument to rebuild.`
+          throw new Error(error)
+        }
+        try {
+          config.load(template.template, template.instance)
+        } catch( e ) {
+          errorHandler(e)
+        }
+      }
+
+      config.addAssociationsFromTests(config.tests);
+    }
+
+    createConfigExport = () => {
+      const config = createConfig()
+      initConfig(config)
+      config.rebuild({ isModule: true })
+      return config
+    }
+    moduleFromJSFile.exports = createConfigExport
   }
 
 }

package/package.json

@@ -63,6 +63,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.5.8-beta.56",
+  "version": "7.5.8-beta.58",
   "license": "ISC"
 }

package/src/config.js

@@ -940,12 +940,12 @@ class Config {
         return query
       } else {
         const config = { ...queryOrConfig }
+        delete config.where
         if (options.isModule) {
           // things like webpack rewrite the functions if there are constants so this compare does not work
           delete config.generators
           delete config.semantics
         } else {
-          delete config.where
           config.generators = (config.generators || []).map((generator) => {
             generator = {...generator}
             delete generator.where
@@ -969,12 +969,6 @@ class Config {
     }
 
     const sameQueries = helpers.safeEquals(toCanonicalQueries(template.queries || []).map(helpers.updateQueries), toCanonicalQueries(instance.queries || []))
-    if (!(instance && sameQueries && sameFragments)) {
-      console.log('options.isModule', options.isModule)
-      console.log('sameQueries', sameQueries)
-      console.log('template.queries', toCanonicalQueries(template.queries || []).map(helpers.updateQueries))
-      console.log('instance.queries', toCanonicalQueries(instance.queries || []))
-    }
     return !(instance && sameQueries && sameFragments)
   }