theprogrammablemind 7.1.4-beta.3

package/src/digraph.js

@@ -0,0 +1,110 @@
+const toA = (edge) => {
+  if (Array.isArray(edge)) {
+    return edge
+  } else {
+    return [edge.child, edge.parent]
+  }
+}
+
+class Digraph {
+  // edges maybe either [child, parent] or { child, parent }
+  constructor (edges = []) {
+    this.edges = edges
+  }
+
+  /*
+  edges () {
+    return this.edges
+  }
+*/
+  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) => {
+        e = toA(e)
+        if (e[from] === n) {
+          acdcs.add(e[to])
+          if (!seen.has(e[to])) {
+            todo.push(e[to])
+            seen.add(e[to])
+          }
+        }
+      })
+    }
+    return acdcs
+  }
+
+  isA (low, high) {
+    if (low === high) {
+      return true
+    }
+    return this.ancestors(low).has(high)
+  }
+
+  lessThan (low, high) {
+    if (low === high) {
+      return false
+    }
+    return this.ancestors(low).has(high)
+  }
+
+  descendants (s) {
+    return this.acdcs(s, 1, 0)
+  }
+
+  ancestors (s) {
+    return this.acdcs(s, 0, 1)
+  }
+
+  minima (nodes) {
+    let minima = new Set(nodes)
+    const ancestors = new Set([])
+    nodes.forEach((node) => {
+      this.ancestors(node).forEach((n) => ancestors.add(n))
+    })
+    ancestors.forEach((n) => minima.delete(n))
+    if (minima.size === 0) {
+      // all unrelated
+      minima = new Set(nodes)
+    }
+    return minima
+  }
+
+  maxima (nodes) {
+    const maxima = new Set(nodes)
+    const descendants = new Set([])
+    nodes.forEach((node) => {
+      this.descendants(node).forEach((n) => descendants.add(n))
+    })
+    descendants.forEach((n) => maxima.delete(n))
+    return maxima
+  }
+
+  add (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]])
+    }
+  }
+
+  order (todo) {
+    const ordered = []
+    while (todo.length > 0) {
+      const nodes = this.minima(todo)
+      todo = todo.filter((e) => !nodes.has(e))
+      for (const node of nodes) {
+        ordered.push(node)
+      }
+      // ordered = ordered.concat([...nodes])
+    }
+    return ordered
+  }
+}
+
+module.exports = Digraph

package/src/flatten.js

@@ -0,0 +1,143 @@
+const { isArray, isObject, isCompound } = require('./helpers')
+const _ = require('lodash')
+
+const DEBUG = (...args) => {
+//  DEBUG(...args)
+}
+
+const flattens = (markers, contexts) => {
+  let flats = []
+  for (const context of contexts) {
+    // const [more, _] = flatten(markers, context)
+    const more = flatten(markers, context)[0]
+    flats = flats.concat(more)
+  }
+  return flats
+}
+
+const accumulate = (accumulator, nexts) => {
+  const accumulatorPrime = []
+  for (const current of accumulator) {
+    for (const next of nexts) {
+      const nextCurrent = _.clone(current)
+      nextCurrent.push(next)
+      accumulatorPrime.push(nextCurrent)
+    }
+  }
+  return accumulatorPrime
+}
+
+const cartesianHelper = (accumulator, b, ...c) => {
+  if (b) {
+    return cartesianHelper(accumulate(accumulator, b), ...c)
+  } else {
+    return accumulator
+  }
+}
+
+const cartesian = (...factors) => {
+  return cartesianHelper([[]], ...factors)
+}
+
+const zip = (a1, a2) => {
+  return a1.map(function (value, index) {
+    return [value, a2[index]]
+  })
+}
+
+const flattenListHelper = (markers, values) => {
+  const flats = []
+  let wasFlattened = false
+  let singles = []
+  for (const value of values) {
+    if (!isCompound(value)) {
+      singles.push(value)
+    } else {
+      const [more, wf] = flatten(markers, value)
+      if (wf) {
+        wasFlattened = wasFlattened || wf
+        flats.push(more)
+      } else {
+        singles = singles.concat(more)
+      }
+    }
+  }
+
+  // product does weirdness with only choice
+  if (!wasFlattened) {
+    return [[singles], wasFlattened]
+  } else {
+    const results = []
+    for (const flat of cartesian(...flats)) {
+      results.push(singles.concat(flat))
+    }
+    return [results, wasFlattened]
+  }
+}
+
+// returns (list, wasFlattened)
+const flatten = (markers, value) => {
+  if (isArray(value)) {
+    return flattenListHelper(markers, value)
+  }
+
+  const marker = value.marker
+  let properties = value
+
+  // if you want to pull up conj properties fix this to do to the other part
+  // split = marker in markers
+  const split = markers.includes(marker)
+  if (split) {
+    if ('value' in properties) {
+      return [properties.value, true]
+    } else {
+      return [[value], false]
+    }
+  }
+
+  const keys = []
+  const valuess = []
+  const unchanged = {}
+  DEBUG('properties', JSON.stringify(properties, null, 2))
+  for (const key in properties) {
+    let wf = false
+    let values
+    // if isinstance(properties[key], Context) {
+    if (isObject(properties[key])) {
+      const context = properties[key];
+      [values, wf] = flatten(markers, context)
+    // } else if (isinstance(properties[key], list)) {
+    } else if (isArray(properties[key])) {
+      [values, wf] = flattenListHelper(markers, properties[key])
+    } else {
+      values = [properties[key]]
+    }
+
+    if (wf) {
+      keys.push(key)
+      valuess.push(values)
+    } else {
+      unchanged[key] = values[0]
+    }
+  }
+
+  const propertiess = []
+  DEBUG('-----------> valuess', JSON.stringify(valuess))
+  DEBUG('-----------> cartesian(valuess)', JSON.stringify(cartesian(valuess)))
+  // for (let values of itertools.product(*valuess)) {
+  const cp = cartesian(...valuess)
+  DEBUG('-----------> cp', JSON.stringify(cp))
+  for (const values of cartesian(...valuess)) {
+    // properties = copy.deepcopy(unchanged)
+    properties = _.cloneDeep(unchanged)
+    // for key, value in zip(keys, values) {
+    for (const [key, value] of zip(keys, values)) {
+      properties[key] = value
+    }
+    propertiess.push(properties)
+  }
+
+  return [propertiess, valuess.length > 0]
+}
+
+module.exports = { flattens, flatten, cartesian, accumulate }

package/src/generators.js

@@ -0,0 +1,282 @@
+const { args: contextArgs, normalizeGenerator } = require('./helpers')
+const Lines = require('../lines')
+const sortJson = require('sort-json')
+const helpers = require('./helpers')
+
+class Generator {
+  // constructor ({ match, apply, uuid, index, km, priority, notes }) {
+  constructor (generator) {
+    generator = normalizeGenerator(generator)
+    const { match, apply, uuid, index, km, priority, where, notes, debug } = generator
+    this.match = match
+    this._apply = apply
+    this.uuid = uuid
+    this.index = index
+    this.km = km
+    this.priority = priority || 0
+    this.notes = notes
+    this.where = where
+    this.callId = debug
+  }
+
+  getAPI (config) {
+    if (config && config.getAPI) {
+      return config.getAPI(this.uuid)
+    }
+  }
+
+  getAPIs (config) {
+    if (config && config._api && config._api.multiApi) {
+      return config._api.apis
+    }
+  }
+
+  toLabel () {
+    const where = this.where ? `where: "${this.where}"` : ''
+    if (!this.km) {
+      return where
+    }
+    return `KM '${this.km}' ordinal: ${this.index} ${where}`
+  }
+
+  toString () {
+    return `Generator(${this.match}, ${this._apply})`
+  }
+
+  matches (baseArgs, objects, context, hierarchy, config, options = {}) {
+    if (objects && objects.namespaced) {
+      objects = objects.namespaced[this.uuid]
+    }
+    // return this.match({ ...args, args: contextArgs(context, hierarchy), objects, global: objects, hierarchy, context, api: this.getAPI(config) })
+    const callId = baseArgs.calls.current()
+    const moreArgs = { 
+            uuid: this.uuid, 
+            args: contextArgs(context, hierarchy), 
+            objects, 
+            global: objects, 
+            // hierarchy, 
+            context, 
+            callId,
+            api: this.getAPI(config),
+            apis: this.getAPIs(config) 
+          }
+    const args = Object.assign({}, baseArgs, moreArgs)
+    // return this.match(args)
+    const matches = this.match(args)
+    if ((matches && (options.debug || {}).match)
+        ||
+        callId == this.callId) {
+      debugger; // next line is the matcher
+      this.match(args)
+    }
+    return matches
+  }
+
+  apply (baseArgs, objects, g, gs, context, hierarchy, config, response, log, options = {}) {
+    if (!log) {
+      throw 'generators.apply argument log is required'
+    }
+
+    // this.getAPI(config)
+    let n = (id) => id
+    if (config && 'nsToString' in config) {
+      n = (id) => config.nsToString(id)
+    }
+    if (objects && objects.namespaced) {
+      objects = objects.namespaced[this.uuid]
+    }
+    const km = (name) => config.getConfig(name)
+    const callId = baseArgs.calls.current()
+    const moreArgs = { 
+            callId, 
+            uuid: this.uuid, 
+            // km, 
+            args: contextArgs(context, hierarchy), 
+            objects, 
+            log, 
+            global: 
+            objects, 
+            g, 
+            n, 
+            hierarchy, 
+            context, 
+            uuid: this.uuid, 
+            gs, 
+            config, 
+            response, 
+            api: this.getAPI(config), 
+            apis: this.getAPIs(config) 
+          }
+    const args = Object.assign({}, baseArgs, moreArgs)
+    // if (this.callId) {
+    // greg
+    /*
+    if (callId == 'call11' && this.callId) {
+      debugger;
+    }
+    */
+    if ((options.debug || {}).apply
+        ||
+        callId == this.callId) {
+      debugger
+    }
+    return this._apply(args)
+  }
+}
+
+class Generators {
+  constructor (generators, logs = []) {
+    generators = (generators || []).map((generator) => {
+      if (generator instanceof Generator) {
+        return generator
+      } else {
+        return new Generator(generator)
+      }
+    })
+    this.defaults = []
+    const priorityToGenerators = {}
+    const add = (priority, value) => {
+      if (!priorityToGenerators[priority]) {
+        priorityToGenerators[priority] = []
+      }
+      priorityToGenerators[priority].push(value)
+    }
+    for (const generator of generators) {
+      const priority = generator.priority
+      add(priority, generator)
+    }
+    this.generators = []
+    for (const key of Object.keys(priorityToGenerators).sort()) {
+      this.generators = this.generators.concat(priorityToGenerators[key])
+    }
+    // this.generators = generators
+    this.logs = logs
+  };
+
+  // assumed - properties added to contexts before the generators are called. For setting paraphrase property
+  apply (args, contexts, assumed = {}, options = {}) {
+    const config = args.config
+    const objects = args.objects
+    const hierarchy = args.hierarchy
+    const response = args.response
+    if (Array.isArray(contexts)) {
+      // no-op
+    } else if (typeof contexts === 'object') {
+      contexts = [contexts]
+    } else {
+      return String(contexts)
+    }
+
+    const contextsPrime = []
+    for (const icontext in contexts) {
+      let context = contexts[icontext]
+      context = Object.assign({}, context, assumed)
+      // let context_prime = JSON.stringify(context);
+      let contextPrime = context
+      let applied = false
+      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)) {
+          const g = (context, options) => {
+            const r = this.apply(args, context, Object.assign({}, ((options||{}).assumed || {}), assumed), options)
+            if (Array.isArray(r)) {
+              return r.join(' ')
+            } else {
+              return r
+            }
+          }
+          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 {
+            contextPrime = generator.apply(args, objects, g, args.gs, context, hierarchy, config, response, log)
+          } catch( e ) {
+            // the next if handle this
+            contextPrime = null
+            if (e.stack && e.message) {
+              errorMessage = `Error applying generator '${generator.notes}'. Error is ${e.toString()} stack is ${e.stack}. Generator is ${generator.toString()}`
+            } else if (e.error) {
+              errorMessage = `Error applying generator '${generator.notes}'. Error is ${e.error.join()}. Generator is ${generator.toString()}`
+            } else {
+							errorMessage = e.toString()
+						}
+          }
+          if (!contextPrime && contextPrime !== '') {
+            const widths = [10, 10, 90]
+            const lines = new Lines(widths)
+            lines.setElement(0, 0, 'Generator')
+            const source = `${generator.km}/#${generator.index}`
+            lines.setElement(0, 2, `ERROR while applying (${source}) ${generator.toLabel()}`)
+            lines.newRow()
+            lines.setElement(0, 2, generator.toString())
+            lines.newRow()
+            lines.setElement(0, 1, 'TO')
+            lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(sortJson(context, { depth: 25 })))})`)
+            lines.setElement(1, 2, JSON.stringify(sortJson(context, { depth: 25 }), null, 2))
+            lines.newRow()
+            lines.setElement(0, 1, 'STACK')
+            lines.setElement(0, 2, stack)
+						lines.newRow()
+						lines.setElement(0, 1, 'DEBUG')
+						lines.setElement(0, 2, `To debug this use args.callId == '${args.calls.current()}'`)
+            lines.newRow()
+            lines.setElement(0, 1, 'ERROR')
+            lines.setElement(0, 2, errorMessage)
+            this.logs.push(lines.toString())
+            const message = `ERROR while applying (${source}) ${generator.toLabel()}\n to\n ${JSON.stringify(context, null, 2)}.\n${errorMessage}'`
+            // this.logs.push(message)
+            // return [message]
+            args.calls.pop()
+            throw { error: [message], logs: this.logs }
+          }
+          if (((config || {}).config || {}).debug) {
+            const widths = [10, 10, 90]
+            const lines = new Lines(widths)
+            lines.setElement(0, 0, 'Generator')
+            if (generator.index > -1 && generator.km) {
+              // lines.setElement(0, 2, `KM '${generator.km}' ordinal: ${generator.index}`)
+              lines.setElement(0, 2, generator.toLabel())
+            }
+            lines.newRow()
+            lines.setElement(0, 1, 'APPLIED')
+            lines.setElement(0, 2, generator.toLabel())
+            lines.newRow()
+            lines.setElement(0, 2, generator.toString())
+            lines.newRow()
+            lines.setElement(0, 1, 'RESULT')
+            lines.setElement(0, 2, contextPrime)
+            lines.newRow()
+            lines.setElement(0, 1, 'STACK')
+            lines.setElement(0, 2, stack)
+            lines.newRow()
+						lines.newRow()
+						lines.setElement(0, 1, 'DEBUG')
+						lines.setElement(0, 2, `To debug this use args.callId == '${args.calls.current()}'`)
+            lines.setElement(0, 1, 'TO')
+            lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(sortJson(context, { depth: 25 })))})`)
+            lines.setElement(1, 2, JSON.stringify(sortJson(context, { depth: 25 }), null, 2))
+            this.logs.push(lines.toString())
+          }
+          applied = true
+          break
+        }
+      }
+      args.calls.pop()
+      if (!applied && ((config || {}).config || {}).debug) {
+        const widths = [10, 10, 90]
+        const lines = new Lines(widths)
+        lines.setElement(0, 0, 'Generator')
+        lines.setElement(0, 2, 'No generator applied')
+        lines.newRow()
+        lines.setElement(0, 1, 'TO')
+        lines.setElement(0, 2, JSON.stringify(context, null, 2))
+        this.logs.push(lines.toString())
+      }
+      contextsPrime.push(contextPrime)
+    }
+    return contextsPrime
+  }
+}
+
+module.exports = { Generator, Generators, normalizeGenerator }