samovar-py 0.6__py3-none-any.whl

samovar/ast.py

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+
+from collections import namedtuple
+
+
+# Python 2/3
+try:
+    unicode = unicode
+except NameError:
+    unicode = str
+
+
+World = namedtuple('World', ['scenarios'])
+
+
+class Rule(namedtuple('Rule', ['pre', 'words', 'post'])):
+    __slots__ = ()
+
+    def format(self, unifier):
+        return join_sentence_parts([unicode(t.subst(unifier)) for t in self.words])
+
+    def to_json(self):
+        return join_sentence_parts([unicode(t) for t in self.words])
+
+
+Scenario = namedtuple('Scenario', ['name', 'propositions', 'rules', 'goal'])
+Cond = namedtuple('Cond', ['exprs', 'bindings'])
+Assert = namedtuple('Assert', ['term'])
+Retract = namedtuple('Retract', ['term'])
+
+
+def join_sentence_parts(parts):
+    acc = u''
+    quote_open = False
+    for part in parts:
+        last = '' if not acc else acc[-1]
+        if last == '':
+            acc += part
+        elif last == '"' and quote_open:
+            acc += part
+        elif last == '"' and not quote_open:
+            if part in (u'.', u',', u'!', u'?'):
+                acc += part
+            else:
+                acc += ' ' + part
+        elif last == ',' and part == u'"' and not quote_open:
+            acc += ' ' + part
+        elif last in (u'.', u',', u'!', u'?', u"'") and part == u'"' and not quote_open:
+            acc += part
+        elif part in (u'.', u',', u'!', u'?', u"'", u'"'):
+            acc += part
+        else:
+            acc += u' ' + part
+        if part == '"':
+            quote_open = not quote_open
+    return acc

samovar/database.py

@@ -0,0 +1,74 @@
+from samovar.ast import Assert, Retract
+
+
+class Database(object):
+    """A database is a set of things true at some point in time in a world."""
+
+    def __init__(self, propositions, sorted_search=True):
+        """Create a new Database object with the given propositions.
+
+        While the construction and iteration of the underlying set in Python 2 seems to be
+        stable, when running under Python 3, we get an unpredictable order when iterating
+        over the set.  The `sorted_search` option controls whether we sort the iterable
+        before making matches, so that we can accumulate them in a predictable order.
+        This is valuable for tests, but can be turned off to improve performance.
+
+        """
+        self.sorted_search = sorted_search
+        self.contents = set()
+        for term in propositions:
+            self.contents.add(term)
+
+    def clone(self):
+        return Database(self.contents, sorted_search=self.sorted_search)
+
+    def add(self, term):
+        self.contents.add(term)
+
+    def remove(self, term):
+        self.contents.remove(term)
+
+    def match_all(self, patterns, env):
+        """Find all matches for the given patterns in the database, and return a list of unifiers.
+
+        `database` is an iterable of `Term`s.
+        `patterns` is a list of `Assert`s and `Retract`s.
+        `env` is a dict mapping `Var` names to `Term`s (a previous unifier.)
+
+        """
+        if not patterns:
+            return [env]
+        envs = []
+        pattern = patterns[0]
+
+        if isinstance(pattern, Assert):
+            for proposition in (sorted(self.contents) if self.sorted_search else self.contents):
+                unifier = pattern.term.match(proposition, env, unique_binding=True)
+                if unifier is None:
+                    continue
+                envs.extend(self.match_all(patterns[1:], unifier))
+
+        elif isinstance(pattern, Retract):
+            expanded_pattern = pattern.term.subst(env)
+
+            # To test a negative match, we require that there are
+            # no free variables remaining in our pattern.  If there are,
+            # it will simply not match.  TODO add a flag to turn this
+            # check on to support better debugging.
+
+            # free_vars = set()
+            # expanded_pattern.collect_variables(free_vars)
+            # if free_vars:
+            #     # TODO: better exception than this
+            #     raise NotImplementedError
+
+            # now we simply check if the term exists in the database.
+            # if it does not, we recurse down to the next clause in the pattern.
+
+            if not (expanded_pattern in self.contents):
+                envs.extend(self.match_all(patterns[1:], env))
+
+        else:
+            raise NotImplementedError
+
+        return envs

samovar/generators/base.py

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+
+import sys
+
+from samovar.ast import Assert, Retract
+
+
+# Python 2/3
+try:
+    xrange = xrange
+except NameError:
+    xrange = range
+
+# Python 2/3
+try:
+    unicode = unicode
+except NameError:
+    unicode = str
+
+
+class Event(object):
+    def __init__(self, rule, unifier):
+        self.rule = rule
+        self.unifier = unifier
+
+    def to_json(self):
+        u = dict([(unicode(k), unicode(v)) for k, v in self.unifier.items()])
+        return [self.rule.to_json(), u]
+
+    def __str__(self):
+        return self.rule.format(self.unifier)
+
+
+class BaseGenerator(object):
+    def __init__(self, world, scenario, **kwargs):
+        self.world = world
+        self.scenario = scenario
+
+    def goal_is_met(self, state):
+        matches = state.match_all(self.scenario.goal.exprs, self.scenario.goal.bindings)
+        return len(matches) > 0
+
+    def candidate_rules(self, state, require_change=False):
+        """A generator."""
+        for rule in self.scenario.rules:
+            for unifier in state.match_all(rule.pre.exprs, rule.pre.bindings):
+                if require_change and not rule.post.exprs:
+                    # Rules that don't change the state of the world are not worth considering.
+                    continue
+                yield (rule, unifier)
+
+    def update_state(self, state, env, rule):
+        for expr in rule.post.exprs:
+            term = expr.term.subst(env)
+            if isinstance(expr, Assert):
+                state.add(term)
+            elif isinstance(expr, Retract):
+                state.remove(term)
+
+    def debug_state(self, state, label):
+        sys.stderr.write(":::: {} State [\n".format(label))
+        for term in sorted(state.contents):
+            sys.stderr.write("::::   {}\n".format(term))
+        sys.stderr.write(":::: ]\n")

samovar/generators/breadthfirst.py

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+
+"""A breadth-first searching Generator that finds the
+shortest path of events that leads to the goal state
+(if any such path exists).
+"""
+
+import sys
+import time
+
+from samovar.ast import Assert, Retract
+from samovar.database import Database
+
+from .base import Event, BaseGenerator
+
+
+class BreadthFirstGenerator(BaseGenerator):
+    def __init__(self, world, scenario, verbosity=0, sorted_search=True, randomness=None):
+        self.world = world
+        self.scenario = scenario
+        self.verbosity = verbosity
+        self.sorted_search = sorted_search
+        self.random = randomness
+
+    def generate_events(self, **kwargs):
+        situations = [
+            ([], Database(self.scenario.propositions, sorted_search=self.sorted_search))
+        ]
+
+        seen_states = set()
+
+        while True:
+            new_situations = []
+            if self.verbosity >= 1:
+                sys.stderr.write("Considering {} situations\n".format(len(situations)))
+                start_time = time.time()
+            for (events, state) in situations:
+                for rule, unifier in self.candidate_rules(state, require_change=True):
+                    new_event = Event(rule, unifier)
+                    new_state = state.clone()
+                    self.update_state(new_state, unifier, rule)
+                    froz = frozenset(new_state.contents)
+                    if froz in seen_states:
+                        continue
+                    seen_states.add(froz)
+                    new_events = events + [new_event]
+                    if self.goal_is_met(new_state):
+                        return new_events
+                    new_situations.append(
+                        (new_events, new_state)
+                    )
+            if self.verbosity >= 1:
+                end_time = time.time()
+                duration = end_time - start_time
+                sys.stderr.write("Considered {} situations in {} seconds ({} situations / second)\n".format(len(situations), duration, float(len(situations))/duration))
+                sys.stderr.write("Installing {} new situations\n".format(len(new_situations)))
+            situations = new_situations

samovar/generators/depthfirst.py

@@ -0,0 +1,73 @@
+# encoding: UTF-8
+
+# FIXME: just a sketch for now
+
+import sys
+import time
+
+from samovar.ast import Assert, Retract
+from samovar.database import Database
+
+from .base import Event, BaseGenerator
+
+
+class DepthFirstGenerator(BaseGenerator):
+    def __init__(self, world, scenario, verbosity=0, sorted_search=True, randomness=None):
+        self.world = world
+        self.scenario = scenario
+        self.verbosity = verbosity
+        self.sorted_search = sorted_search
+        self.random = randomness
+        self.seen_states = set()
+
+    def generate_events(self, **kwargs):
+        self.seen_states = set()
+
+        # Create initial stacks.
+        state = Database(self.scenario.propositions, sorted_search=self.sorted_search)
+        candidate_rules = list(self.candidate_rules(state, require_change=True))
+        stack = [
+            [None, state, candidate_rules, 0]
+        ]
+
+        # Loop, doing work at the top of the stack.
+        done = False
+        counter = 0
+        while not done:
+            counter += 1
+            [last_event, state, candidate_rules, cr_index] = stack[-1]
+            if self.verbosity >= 1 and counter % 1000 == 0:
+                sys.stderr.write("Stack depth {}, candidate count {}, index {}\n".format(
+                    len(stack), len(candidate_rules), cr_index
+                ))
+            if cr_index > (len(candidate_rules) - 1):
+                # we've exhausted all the candidates on this level.  backtrack.
+                if self.verbosity >= 1:
+                    sys.stderr.write("*** Backtracking\n")
+                stack.pop()
+                continue
+
+            # otherwise, try to make a match.
+            rule, unifier = candidate_rules[cr_index]
+
+            new_event = Event(rule, unifier)
+            new_state = state.clone()
+            self.update_state(new_state, unifier, rule)
+            if self.verbosity >= 2:
+                self.debug_state(new_state, "Intermediate")
+            if self.goal_is_met(new_state):
+                return [e[0] for e in stack if e[0] is not None] + [new_event]
+
+            froz = frozenset(new_state.contents)
+            if froz in self.seen_states:
+                stack[-1][3] += 1   # inc cr_index. TODO this is so ugly
+                continue
+            self.seen_states.add(froz)
+
+            # otherwise, descend to try to extend the sequence of events we've got.
+            new_candidate_rules = list(self.candidate_rules(new_state, require_change=True))
+            stack.append(
+                [new_event, new_state, new_candidate_rules, 0]
+            )
+
+        return None

samovar/generators/stochastic.py

@@ -0,0 +1,62 @@
+# encoding: UTF-8
+
+import sys
+
+from samovar.database import Database
+
+from .base import xrange, Event, BaseGenerator
+
+
+class StochasticGenerator(BaseGenerator):
+    def __init__(self, world, scenario, verbosity=0, sorted_search=True, randomness=None):
+        self.world = world
+        self.scenario = scenario
+        self.verbosity = verbosity
+        self.sorted_search = sorted_search
+        self.random = randomness
+        self.reset_state()
+
+    def reset_state(self):
+        self.state = Database(self.scenario.propositions, sorted_search=self.sorted_search)
+
+    def generate_events(self, min_count=0, max_count=100, lengthen_factor=1.5):
+        acceptable = False
+        count = min_count
+        while not acceptable:
+            if self.verbosity >= 1:
+                sys.stderr.write("Generating {} events\n".format(count))
+            self.reset_state()
+            if self.verbosity >= 2:
+                self.debug_state(self.state, "Initial")
+            events = []
+            for i in xrange(0, count):
+                event = self.generate_event()
+                if event is None:
+                    break
+                events.append(event)
+            if self.verbosity >= 2:
+                self.debug_state(self.state, "Final")
+            acceptable = self.goal_is_met(self.state)
+            if not acceptable:
+                count = int(float(count) * lengthen_factor)
+            if count > max_count:
+                raise ValueError("{}: count exceeds maximum".format(self.scenario.name))
+        return events
+
+    def generate_event(self):
+        candidates = list(self.candidate_rules(self.state))
+
+        if self.verbosity >= 3:
+            sys.stderr.write("Candidate rules:\n")
+            for rule, unifiers in candidates:
+                sys.stderr.write("-> " + rule.to_json() + "\n")
+                sys.stderr.write("---> {}\n".format(unifiers))
+            sys.stderr.write("")
+
+        if not candidates:
+            return None
+        rule, unifier = self.random.choice(candidates)
+        self.update_state(self.state, unifier, rule)
+        if self.verbosity >= 3:
+            self.debug_state(self.state, "Intermediate")
+        return Event(rule, unifier)

samovar/main.py

@@ -0,0 +1,138 @@
+from argparse import ArgumentParser
+import codecs
+import json
+import sys
+
+from samovar.parser import Parser
+from samovar.generators.breadthfirst import BreadthFirstGenerator
+from samovar.generators.depthfirst import DepthFirstGenerator
+from samovar.generators.stochastic import StochasticGenerator
+from samovar.randomness import CannedRandomness
+
+
+def sys_main():
+    return main(sys.argv[1:])
+
+
+def main(args):
+    argparser = ArgumentParser()
+
+    argparser.add_argument(
+        'input_files', nargs='+', metavar='FILENAME', type=str,
+        help='Source files containing the scenario descriptions'
+    )
+    argparser.add_argument(
+        "--verbosity", type=int, default=0,
+        help="Show some information about the world as generation takes place"
+    )
+    argparser.add_argument(
+        "--verbose", action="store_true",
+        help="Show some progress information (alias for --verbosity=1)"
+    )
+    argparser.add_argument(
+        "--debug", action="store_true",
+        help="Show state before and after each move (alias for --verbosity=2)"
+    )
+    argparser.add_argument(
+        "--dump-ast", action="store_true",
+        help="Just show the AST and stop"
+    )
+    argparser.add_argument(
+        "--generator", choices=('stochastic', 'breadthfirst', 'depthfirst'), default='stochastic',
+        help="Specify which generator engine to use"
+    )
+    argparser.add_argument(
+        "--generate-scenarios", type=str, default=None,
+        help="If given, generate only these scenarios"
+    )
+    argparser.add_argument(
+        "--lengthen-factor", type=float, default=2.0,
+        help="When scenario goal was not met, multiply number of events to generate by this"
+    )
+    argparser.add_argument(
+        "--min-events", type=int, default=1,
+        help="Generate at least this many events for each scenario"
+    )
+    argparser.add_argument(
+        "--max-events", type=int, default=1000000,
+        help="Conclude that something has gone wrong and abort if more than this many events are generated"
+    )
+    argparser.add_argument(
+        "--output-type", choices=('naive-text', 'events-json', 'scenarios-json',), default='naive-text',
+        help="Specify what to output and in what format"
+    )
+    argparser.add_argument(
+        "--deterministic", action="store_true",
+        help="Make the output deterministic, at the cost of performance. "
+             "Primarily useful for reproducibility during testing."
+    )
+    argparser.add_argument(
+        "--seed", type=int, default=None,
+        help="Set random seed of the Python random number generator, when it is in use."
+    )
+    argparser.add_argument('--version', action='version', version="%(prog)s 0.6")
+
+    options = argparser.parse_args(args)
+
+    verbosity = options.verbosity
+    if options.verbose:
+        verbosity = max(verbosity, 1)
+    if options.debug:
+        verbosity = max(verbosity, 2)
+
+    generator_cls = {
+        'breadthfirst': BreadthFirstGenerator,
+        'depthfirst': DepthFirstGenerator,
+        'stochastic': StochasticGenerator,
+    }[options.generator]
+
+    text = ''
+    for arg in options.input_files:
+        with codecs.open(arg, 'r', encoding='UTF-8') as f:
+            text += f.read()
+
+    p = Parser(text)
+    ast = p.world()
+    if options.dump_ast:
+        print(ast)
+        sys.exit(0)
+
+    if options.deterministic:
+        randomness = CannedRandomness()
+    else:
+        import random
+        if options.seed is not None:
+            random.seed(options.seed)
+        randomness = random
+
+    event_buckets = []
+    for n, scenario in enumerate(ast.scenarios):
+        if verbosity >= 1:
+            sys.stderr.write("{}. {}\n".format(n, scenario.name))
+        if scenario.goal is None:
+            continue
+        if options.generate_scenarios is not None and scenario.name not in options.generate_scenarios:
+            continue
+        g = generator_cls(
+            ast, scenario,
+            verbosity=verbosity, sorted_search=options.deterministic, randomness=randomness
+        )
+        events = g.generate_events(
+            min_count=options.min_events, max_count=options.max_events, lengthen_factor=options.lengthen_factor
+        )
+        event_buckets.append(events)
+
+    if options.output_type == 'naive-text':
+        for b in event_buckets:
+            for e in b:
+                sys.stdout.write("%s\n" % e)
+            sys.stdout.write("\n")
+    elif options.output_type == 'events-json':
+        def jsonify_bucket(b):
+            return [e.to_json() for e in b]
+        jsonified_buckets = [jsonify_bucket(b) for b in event_buckets]
+        sys.stdout.write(json.dumps(jsonified_buckets, indent=4, sort_keys=True))
+    elif options.output_type == 'scenarios-json':
+        raise NotImplementedError("'scenarios-json' output-type not currently implemented")
+    else:
+        raise NotImplementedError('Not a valid output-type: {}'.format(options.output_type))

samovar/parser.py

@@ -0,0 +1,166 @@
+# encoding: UTF-8
+
+from samovar.ast import World, Scenario, Rule, Cond, Assert, Retract
+from samovar.terms import Term, Var
+from samovar.scanner import Scanner
+
+
+# World         ::= {Scenario}.
+# Scenario      ::= "scenario" Atom "{" {Import | Proposition | Rule | Goal} ["." | ","] "}".
+# Import        ::= "import" Atom.
+# Goal          ::= "goal" Cond.
+# Proposition   ::= Term.
+# Rule          ::= Cond {Var | Atom | Punct} Cond.
+# Cond          ::= "[" Expr {"," Expr} ["where" {Var "=" Term [","]}"]".
+# Expr          ::= Term | NotSym Term.
+# Term          ::= Var | Atom ["(" Term {AndSym Term} ")"].
+# Var           ::= Qmark | Greek.
+# Qmark         ::= '?' Atom.
+# Greek         ::= <<one of: αβγδεζθικλμνξοπρστυφχψω>>.
+# Atom          ::= <<A-Za-z_>> <<A-Za-z0-9_-'>>*.
+# Punct         ::= <<"',.;:?!>>.
+# NotSym        ::= '~' | '¬'.
+# AndSym        ::= ',' | '∧'.
+
+
+class SamovarSyntaxError(ValueError):
+    pass
+
+
+def variables_in_cond(cond):
+    vars_ = set()
+    for expr in cond.exprs:
+        expr.term.collect_variables(vars_)
+    for key, value in cond.bindings.items():
+        vars_.add(Var(key))
+    return vars_
+
+
+class Parser(object):
+    def __init__(self, text):
+        self.scanner = Scanner(text)
+        self.scenario_map = {}
+
+    def world(self):
+        scenarios = []
+        while self.scanner.on('scenario'):
+            scenario = self.scenario()
+            self.scenario_map[scenario.name] = scenario
+            scenarios.append(scenario)
+        return World(scenarios=scenarios)
+
+    def scenario(self):
+        propositions = []
+        rules = []
+        goal = None
+        self.scanner.expect('scenario')
+        self.scanner.check_type('word')
+        name = self.scanner.token
+        self.scanner.scan()
+        self.scanner.expect('{')
+        while not self.scanner.on('}'):
+            if self.scanner.consume('import'):
+                self.scanner.check_type('word')
+                from_name = self.scanner.token
+                self.scanner.scan()
+                from_scenario = self.scenario_map[from_name]
+                rules.extend(from_scenario.rules)
+                propositions.extend(from_scenario.propositions)
+            elif self.scanner.consume('goal'):
+                assert goal is None
+                goal = self.cond()
+            elif self.scanner.on('['):
+                rules.append(self.rule())
+            else:
+                propositions.append(self.proposition())
+            self.scanner.consume('.')
+            self.scanner.consume(',')
+        self.scanner.expect('}')
+        return Scenario(name=name, propositions=propositions, rules=rules, goal=goal)
+
+    def proposition(self):
+        return self.term()
+
+    def rule(self):
+        words = []
+        pre = self.cond()
+        while not self.scanner.on('['):
+            words.append(self.word())
+        post = self.cond()
+
+        if post.bindings:
+            raise SamovarSyntaxError("Consequences of a rule cannot include a `where` clause")
+
+        pre_variables = variables_in_cond(pre)
+
+        words_variables = set(w for w in words if isinstance(w, Var))
+        text = ' '.join([str(w) for w in words])
+        if '?_' in [w.name for w in words_variables]:
+            raise SamovarSyntaxError('Text "{}" contains wildcard'.format(text))
+        extra_vars_in_words = words_variables - pre_variables
+        if extra_vars_in_words:
+            extra_vars = ', '.join([str(v) for v in sorted(extra_vars_in_words)])
+            raise SamovarSyntaxError('Text "{}" contains unbound variables: {}'.format(text, extra_vars))
+
+        post_variables = variables_in_cond(post)
+        if '?_' in [w.name for w in post_variables]:
+            raise SamovarSyntaxError("Consequences contains wildcard")
+        extra_vars_in_post = post_variables - pre_variables
+        if extra_vars_in_post:
+            extra_vars = ', '.join([str(v) for v in sorted(extra_vars_in_words)])
+            raise SamovarSyntaxError("Consequences contains unbound variables: {}".format(extra_vars))
+
+        return Rule(pre=pre, words=words, post=post)
+
+    def cond(self):
+        exprs = []
+        bindings = {}
+        self.scanner.expect('[')
+        if not self.scanner.on(']') and not self.scanner.on('where'):
+            exprs.append(self.expr())
+            while self.scanner.consume(',', u'∧'):
+                exprs.append(self.expr())
+        if self.scanner.consume('where'):
+            while not self.scanner.on(']'):
+                v = self.var()
+                self.scanner.expect('=')
+                t = self.term()
+                bindings[v.name] = t
+                self.scanner.consume(',', u'∧')
+        self.scanner.expect(']')
+        return Cond(exprs=exprs, bindings=bindings)
+
+    def expr(self):
+        if self.scanner.consume('~', u'¬', '!'):
+            return Retract(term=self.term())
+        else:
+            return Assert(term=self.term())
+
+    def term(self):
+        if self.scanner.on_type('variable'):
+            return self.var()
+        self.scanner.check_type('word')
+        constructor = self.scanner.token
+        self.scanner.scan()
+        subterms = []
+        if self.scanner.consume('('):
+            subterms.append(self.term())
+            while self.scanner.consume(','):
+                subterms.append(self.term())
+            self.scanner.expect(')')
+        return Term(constructor, *subterms)
+
+    def word(self):
+        if self.scanner.on_type('variable'):
+            return self.var()
+        self.scanner.check_type('word', 'punct', 'operator')
+        constructor = self.scanner.token
+        self.scanner.scan()
+        return Term(constructor)
+
+    def var(self):
+        self.scanner.check_type('variable')
+        name = self.scanner.token
+        self.scanner.scan()
+        v = Var(name)
+        return v

samovar/randomness.py

@@ -0,0 +1,20 @@
+# Sources of randomness, for Samovar.
+
+
+class CannedRandomness(object):
+    def __init__(self):
+        self.counter = 0
+        self.limit = 1
+
+    def advance(self):
+        self.counter += 1
+        if self.counter > self.limit:
+            self.counter = 0
+            self.limit += 1
+
+    def choice(self, iterable):
+        length = len(iterable)
+        index = self.counter % length
+        selection = iterable[index]
+        self.advance()
+        return selection

samovar/scanner.py

@@ -0,0 +1,120 @@
+# encoding: UTF-8
+
+
+# Python 2/3
+try:
+    unicode = unicode
+except NameError:
+    unicode = str
+
+
+import re
+
+
+GREEK = [
+    (u'?alpha', u'α'),
+    (u'?beta', u'β'),
+    (u'?gamma', u'γ'),
+    (u'?delta', u'δ'),
+    (u'?epsilon', u'ε'),
+    (u'?zeta', u'ζ'),
+    (u'?theta', u'θ'),
+    (u'?iota', u'ι'),
+    (u'?kappa', u'κ'),
+    (u'?lambda', u'λ'),
+    (u'?mu', u'μ'),
+    (u'?nu', u'ν'),
+    (u'?xi', u'ξ'),
+    (u'?omicron', u'ο'),
+    (u'?pi', u'π'),
+    (u'?rho', u'ρ'),
+    (u'?sigma', u'σ'),
+    (u'?tau', u'τ'),
+    (u'?upsilon', u'υ'),
+    (u'?phi', u'φ'),
+    (u'?chi', u'χ'),
+    (u'?psi', u'ψ'),
+    (u'?omega', u'ω'),
+]
+
+
+class Scanner(object):
+    def __init__(self, text):
+        self.text = unicode(text)
+        self.token = None
+        self.type = None
+        self.pos = 0
+        self.scan()
+
+    def near_text(self, length=10):
+        return self.text[self.pos:self.pos + length]
+
+    def scan_pattern(self, pattern, type, token_group=1, rest_group=2):
+        pattern = r'(' + pattern + r')'
+        regexp = re.compile(pattern, flags=re.DOTALL)
+        match = regexp.match(self.text, pos=self.pos)
+        if not match:
+            return False
+        else:
+            self.type = type
+            self.token = match.group(token_group)
+            self.pos += len(self.token)
+            return True
+
+    def scan(self):
+        self.scan_pattern(r'[ \t\n\r]*', 'whitespace')
+        while self.scan_pattern(r'\/\/.*?[\n\r]', 'comment'):
+            self.scan_pattern(r'[ \t\n\r]*', 'whitespace')
+        if self.pos >= len(self.text):
+            self.token = None
+            self.type = 'EOF'
+            return
+        if self.scan_pattern(u'\\~|→|=|¬|∧|∨', 'operator'):
+            return
+        # Note that '?' appears in both `variable` and in `punct`.
+        # This is acceptable however, because in normal prose, the
+        # '?' symbol is never immediately followed by a letter.
+        if self.scan_pattern(r'\?[a-zA-Z_]+', 'variable'):
+            return
+        if self.scan_pattern(r'\,|\.|\;|\:|\?|\!|\"', 'punct'):
+            return
+        if self.scan_pattern(r'\(|\)|\{|\}|\[|\]', 'bracket'):
+            return
+        if self.scan_pattern(r"[a-zA-Z_]['a-zA-Z0-9_-]*", 'word'):
+            return
+        if self.scan_pattern(u'[αβγδεζθικλμνξοπρστυφχψω]', 'variable'):
+            for varname, letter in GREEK:
+                if letter == self.token:
+                    self.token = varname
+                    break
+            assert self.token.startswith('?'), repr(self.token)
+            return
+        if self.scan_pattern(r'.', 'unknown character'):
+            return
+        else:
+            raise AssertionError("this should never happen, self.text=(%s), self.pos=(%s)" % (self.text, self.pos))
+
+    def expect(self, token):
+        if self.token == token:
+            self.scan()
+        else:
+            raise SyntaxError(u"Expected '%s', but found '%s' (near '%s')" %
+                              (token, self.token, self.near_text()))
+
+    def on(self, *tokens):
+        return self.token in tokens
+
+    def on_type(self, *types):
+        return self.type in types
+
+    def check_type(self, *types):
+        if not self.on_type(*types):
+            raise SyntaxError(u"Expected %s, but found %s ('%s') (near '%s')" %
+                              (types, self.type, self.token, self.near_text()))
+
+    def consume(self, *tokens):
+        if self.token in tokens:
+            self.scan()
+            return True
+        else:
+            return False

samovar/terms.py

@@ -0,0 +1,127 @@
+# encoding: UTF-8
+
+
+# Python 2/3
+try:
+    unicode = unicode
+except NameError:
+    unicode = str
+
+
+class AbstractTerm(object):
+    pass
+
+
+class Term(AbstractTerm):
+    def __init__(self, constructor, *subterms):
+        self.t = tuple([constructor] + list(subterms))
+
+    def __lt__(self, other):
+        if isinstance(other, Term):
+            return self.t < other.t
+        else:
+            raise TypeError("'<' not supported between instances of 'Term' and '{}'".format(other.__class__.__name__))
+
+    @property
+    def constructor(self):
+        return self.t[0]
+
+    @property
+    def subterms(self):
+        return self.t[1:]
+
+    def __str__(self):
+        if len(self.subterms) == 0:
+            return self.constructor
+        return u"%s(%s)" % (self.constructor, ', '.join([unicode(s) for s in self.subterms]))
+
+    def __repr__(self):
+        if self.subterms:
+            return "%s(%r, *%r)" % (
+                self.__class__.__name__, self.constructor, self.subterms
+            )
+        else:
+            return "%s(%r)" % (
+                self.__class__.__name__, self.constructor
+            )
+
+    def __eq__(self, other):
+        return isinstance(other, Term) and self.t == other.t
+
+    def __hash__(self):
+        return hash(self.t)
+
+    def is_atom(self):
+        return len(self.subterms) == 0
+
+    def is_ground(term):
+        for subterm in term.subterms:
+            if not subterm.is_ground():
+                return False
+        return True
+
+    def match(self, term, env, **kwargs):
+        """Returns None if no match."""
+        if env is None or self.constructor != term.constructor or len(self.subterms) != len(term.subterms):
+            return None
+        for (subpat, subterm) in zip(self.subterms, term.subterms):
+            env = subpat.match(subterm, env, **kwargs)
+        return env
+
+    def subst(self, env):
+        return Term(self.constructor, *[subterm.subst(env) for subterm in self.subterms])
+
+    def collect_atoms(self, atoms):
+        if self.is_atom():
+            atoms.add(self)
+        else:
+            for subterm in self.subterms:
+                subterm.collect_atoms(atoms)
+
+    def collect_variables(self, vars_):
+        for subterm in self.subterms:
+            subterm.collect_variables(vars_)
+
+
+class Var(AbstractTerm):
+    def __init__(self, name):
+        self.name = unicode(name)
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self.name)
+
+    def __eq__(self, other):
+        return isinstance(other, Var) and self.name == other.name
+
+    def __hash__(self):
+        return hash(self.name)
+
+    def is_atom(self):
+        return False
+
+    def is_ground(term):
+        return False
+
+    def match(self, term, env, **kwargs):
+        if env is None or self.name == '?_':
+            return env
+        if self.name in env:
+            bound_to = env[self.name]
+            return bound_to.match(term, env, **kwargs)
+        if kwargs.get('unique_binding'):
+            if term in env.values():
+                # raise ValueError("Not unique")
+                return None
+        return dict(list(env.items()) + [(self.name, term)])
+
+    def subst(self, env):
+        return env[self.name]
+
+    def collect_atoms(self, atoms):
+        pass
+
+    def collect_variables(self, vars_):
+        vars_.add(self)

samovar/tests.py

@@ -0,0 +1,209 @@
+import unittest
+from unittest import TestCase
+
+from samovar.ast import Assert, Retract, join_sentence_parts
+from samovar.database import Database
+from samovar.terms import Term, Var
+
+
+def t(s, *args):
+    if s.startswith('?'):
+        return Var(s)
+    else:
+        return Term(s, *args)
+
+
+def a(t):
+    return Assert(term=t)
+
+
+def r(t):
+    return Retract(term=t)
+
+
+class TermTestCase(TestCase):
+    def test_term_basic_properties(self):
+        t1 = Term('alice')
+        t2 = Term('actor', t1)
+        v1 = Var('?A')
+        t3 = Term('actor', v1)
+
+        self.assertTrue(t1.is_atom())
+        self.assertFalse(t2.is_atom())
+        self.assertFalse(v1.is_atom())
+        self.assertFalse(t3.is_atom())
+
+        self.assertTrue(t1.is_ground())
+        self.assertTrue(t2.is_ground())
+        self.assertFalse(v1.is_ground())
+        self.assertFalse(t3.is_ground())
+
+        self.assertEqual(t2, Term('actor', Term('alice')))
+
+    def test_term_match_ground(self):
+        t1 = Term('actor', Term('alice'))
+        p1 = Term('actor', Term('alice'))
+        u = p1.match(t1, {})
+        self.assertEqual(u, {})
+
+    def test_term_no_match_ground(self):
+        t1 = Term('actor', Term('alice'))
+        p1 = Term('actor', Term('bob'))
+        self.assertIsNone(p1.match(t1, {}))
+
+    def test_term_match_bind_var(self):
+        t1 = Term('actor', Term('alice'))
+        p1 = Term('actor', Var('?A'))
+        e = {}
+        u = p1.match(t1, e)
+        self.assertEqual(u, {u'?A': Term('alice')})
+        self.assertEqual(e, {})
+
+    def test_term_match_already_bound_var(self):
+        t1 = Term('actor', Term('alice'))
+        p1 = Term('actor', Var('?A'))
+        u = p1.match(t1, {u'?A': Term('alice')})
+        self.assertEqual(u, {u'?A': Term('alice')})
+
+    def test_term_no_match_already_bound_var(self):
+        t1 = Term('actor', Term('alice'))
+        p1 = Term('actor', Var('?A'))
+        u = {u'?A': Term('bob')}
+        self.assertIsNone(p1.match(t1, u))
+
+    def test_term_subst(self):
+        t = Term('actor', Var('?A'))
+        r = t.subst({u'?A': Term('alice')})
+        self.assertEqual(r, Term('actor', Term('alice')))
+
+
+class RenderTestCase(TestCase):
+    def test_join_sentence_parts_1(self):
+        self.assertEqual(
+            join_sentence_parts(['"', "Hello", ",", '"', "said", "the", "mouse", "."]),
+            '"Hello," said the mouse.'
+        )
+
+    def test_join_sentence_parts_2(self):
+        self.assertEqual(
+            join_sentence_parts(["The", "mouse", "asked", ",", '"', "What", "is", "it", "?", '"']),
+            'The mouse asked, "What is it?"'
+        )
+
+    def test_join_sentence_parts_3(self):
+        self.assertEqual(
+            join_sentence_parts(["It", "was", "very", ",", "very", "dark", '.']),
+            'It was very, very dark.'
+        )
+
+
+class DatabaseTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.database = Database([
+            t('actor', t('alice')),
+            t('actor', t('bob')),
+
+            t('drink', t('gin')),
+
+            t('weapon', t('revolver')),
+            t('weapon', t('knife')),
+            t('weapon', t('club')),
+
+            t('holding', t('bob'), t('revolver')),
+            t('holding', t('alice'), t('gin')),
+            t('holding', t('alice'), t('knife')),
+        ])
+
+
+class TestMatchAll(DatabaseTestCase):
+
+    def assertMatchAll(self, query, result):
+        self.assertEqual(self.database.match_all(query, {}), result)
+
+    def test_match_all(self):
+        # Find all actors who are Cody.  Since there is no such actor, this will return no matches.
+        self.assertMatchAll(
+            [a(t('actor', t('cody')))],
+            []
+        )
+        # Find all actors who are Alice.  This will return one match, but no bindings.
+        self.assertMatchAll(
+            [a(t('actor', t('alice')))],
+            [{}]
+        )
+        # Find all drinks.  This will return one match, with ?D bound to the result.
+        self.assertMatchAll(
+            [a(t("drink", t("?D")))],
+            [{'?D': Term('gin')}]               # there was a match, in which ?D was bound
+        )
+        # Find all actors.
+        self.assertMatchAll(
+            [a(t('actor', t('?C')))],
+            [{'?C': Term('alice')}, {'?C': Term('bob')}]
+        )
+        # Find all actors who are holding the revolver.
+        self.assertMatchAll(
+            [a(t('actor', t('?C'))), a(t('holding', t('?C'), t('revolver')))],
+            [{'?C': t('bob')}]
+        )
+        # Find all actors who are holding a weapon.
+        self.assertMatchAll(
+            [a(t('actor', t('?C'))), a(t('weapon', t('?W'))), a(t('holding', t('?C'), t('?W')))],
+            [{'?W': t('knife'), '?C': t('alice')}, {'?W': t('revolver'), '?C': t('bob')}]
+        )
+
+    def test_match_all_with_unique_binding(self):
+        # Find all pairs of actors.  Because the actors must be different, there are only 2 matches.
+        self.assertMatchAll(
+            [a(t('actor', t('?A'))), a(t('actor', t('?B')))],
+            [{'?A': Term('alice'), '?B': Term('bob')}, {'?A': Term('bob'), '?B': Term('alice')}]
+        )
+        # Find all pairs of drinks.  Since there is only one, and we can't return (gin,gin),
+        # there will be no matches.
+        self.assertMatchAll(
+            [a(t('drink', t('?A'))), a(t('drink', t('?B')))],
+            []
+        )
+
+    def test_match_all_with_negation(self):
+        # Find all actors who are not holding the revolver.
+        self.assertMatchAll(
+            [a(t('actor', t('?C'))), r(t('holding', t('?C'), t('revolver')))],
+            [{'?C': t('alice')}]
+        )
+        # Find all actors who are not holding a weapon.  Or rather, all pairs
+        # of (actor, weapon) where the actor is not holding that weapon.
+        self.assertMatchAll(
+            [a(t('actor', t('?C'))), a(t('weapon', t('?W'))), r(t('holding', t('?C'), t('?W')))],
+            [
+                {'?W': t('club'), '?C': t('alice')},
+                {'?W': t('revolver'), '?C': t('alice')},
+                {'?W': t('club'), '?C': t('bob')},
+                {'?W': t('knife'), '?C': t('bob')},
+            ]
+        )
+        # Note that we can't say "Find all actors who aren't Alice".
+        # We can say this:
+        self.assertMatchAll(
+            [a(t('actor', t('?C'))), r(t('actor', t('alice')))],
+            []
+        )
+        # ... but what this is saying is "Find all actors if Alice isn't an actor."
+
+        # For a one-off case, we can do something like this:
+        self.database.add(t('is_alice', t('alice')))
+        self.assertMatchAll(
+            [a(t('actor', t('?C'))), r(t('is_alice', t('?C')))],
+            [{'?C': t('bob')}]
+        )
+
+        # For the general case, we'll need to think about equality tests.
+
+        # Note also that we can't search on negative clauses with free variables:
+        with self.assertRaises(KeyError):
+            self.database.match_all([a(t('actor', t('?C'))), r(t('weapon', t('?W')))], {})
+
+
+if __name__ == '__main__':
+    unittest.main()

samovar_py-0.6.dist-info/METADATA

@@ -0,0 +1,123 @@
+Metadata-Version: 2.1
+Name: samovar-py
+Version: 0.6
+Summary: Samovar: model worlds using propositions and run simulations in them
+Author-email: Chris Pressey <packages@catseye.tc>
+License: This is free and unencumbered software released into the public domain.
+        
+        Anyone is free to copy, modify, publish, use, compile, sell, or
+        distribute this software, either in source code form or as a compiled
+        binary, for any purpose, commercial or non-commercial, and by any
+        means.
+        
+        In jurisdictions that recognize copyright laws, the author or authors
+        of this software dedicate any and all copyright interest in the
+        software to the public domain. We make this dedication for the benefit
+        of the public at large and to the detriment of our heirs and
+        successors. We intend this dedication to be an overt act of
+        relinquishment in perpetuity of all present and future rights to this
+        software under copyright law.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+        IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+        OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+        ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+        OTHER DEALINGS IN THE SOFTWARE.
+        
+        For more information, please refer to <http://unlicense.org/>
+        
+Project-URL: website, https://catseye.tc/node/Samovar
+Classifier: License :: OSI Approved :: The Unlicense (Unlicense)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Artistic Software
+Classifier: Topic :: Games/Entertainment :: Simulation
+Requires-Python: >=2.7,>=3.5
+Description-Content-Type: text/markdown
+
+Samovar
+=======
+
+Version 0.6 | _Entry_ [@ catseye.tc](https://catseye.tc/node/Samovar)
+| _See also:_ [The League of Extraordinarily Dull Gentlemen](https://github.com/catseye/NaNoGenMo-Entries-2018/tree/master/league#readme)
+∘ [The Swallows](https://github.com/catseye/The-Swallows#readme)
+
+- - - -
+
+**Samovar** is a domain-specific language (DSL) for modelling a world using
+propositions (facts), and possible events that can occur based on those facts,
+changing them.
+
+Here is a short example of a Samovar description:
+
+    scenario IgnatzWithBrick {
+      
+        [actor(?A),item(?I),~holding(?A,?I)]  ?A picks up the ?I.   [holding(?A,?I)]
+        [actor(?A),item(?I),holding(?A,?I)]   ?A puts down the ?I.  [~holding(?A,?I)]
+    
+        actor(Ignatz).
+        item(brick).
+    
+        goal [].
+    }
+
+And an implementation of Samovar could take this scenario and use it to,
+among other things, generate textual descriptions of chains of events like
+
+    Ignatz picks up the brick. Ignatz puts down the brick.
+
+Of course, this is a very simple example.  (It doesn't even prevent two
+actors from picking up the same item at the same time!)  For more complex
+examples, and a fuller description of the language, see
+[doc/Samovar.md](doc/Samovar.md), which also serves as a test suite.
+
+### Implementation
+
+The reference implementation of Samovar, `samovar`, is written in Python.
+It can run under either Python 2.7 or Python 3.x (tested with 3.5 or higher.)
+
+### Discussion
+
+This looks like logic programming but the internals are actually much simpler,
+and what it's doing is not logical inference.
+
+The internals are far simpler than an inference engine or a theorem
+prover: there are no logical rules in the database, only propositions, so
+they can be selected by simple pattern-matching rather than full unification.
+
+I originally described it as an "assertion-retraction engine", which could
+be thought of as a highly stylized form of Prolog programming.  Alternately,
+it could be thought of as assigning preconditions and postconditions, like
+in [Hoare logic][], to actions in a world-model.  Instead of constructing a
+proof, though, we simply chain actions together, by selecting any next one
+whose preconditions hold, and altering the world so that its postconditions hold.
+
+In (I think) autumn 2019, I came across the concept of a [production system][],
+and I realized that is basically what Samovar implements.  Researching it
+further, I discovered [CLIPS][], a production system built in 1985,
+and I realized that Samovar is not essentially different from an
+inefficiently-implemented, stripped-down version of CLIPS.
+
+The main innovation in Samovar is the ability to "narrate" the choices the
+production system makes, with human-readable text.
+
+This isn't too surprising, since my goal with Samovar was to make an expressive
+language, a syntax in which the author could write a story generator without
+the undue effort of switching context between prose and code.  Picking logical
+propositions for the "code" and placing them before and after each fragment of
+prose was a reasonably "ergonomic" choice, and happens to coincide with the
+structure of a production system.
+
+[Hoare logic]: https://en.wikipedia.org/wiki/Hoare_logic
+[production system]: https://en.wikipedia.org/wiki/Production_system_(computer_science)
+[CLIPS]: https://en.wikipedia.org/wiki/CLIPS
+
+### TODO
+
+*   Maybe allow variables to be notated so that they can bind reflexively,
+    e.g. `?*A looks at ?*B` can bind both variables to Alice.
+*   Make `?_` work such that you can say `¬holding(?_, club)` to mean
+    "if no one is holding the club".

samovar_py-0.6.dist-info/RECORD

@@ -0,0 +1,19 @@
+samovar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+samovar/ast.py,sha256=AFLiqpr9bBkgQ84UeQhV06nWcA17n41kdIoowpJOOew,1509
+samovar/database.py,sha256=eV0x8JGjAiUq697YvkK0gjIzj8OJMln6IWpT8Dsqdug,2796
+samovar/main.py,sha256=RmUtRT3O7R_IumHDJT6xJel1GTtCrWwqYvN-6DMTHZc,4934
+samovar/parser.py,sha256=bYrtRhXHTAkEj7g9z7Lfua85VcRpzpFxg84_LN4BBwY,5847
+samovar/randomness.py,sha256=4scvXciSZ7W2hINWnLcAZf0ov4RYO8BJ7Zr4tzhnx6Q,475
+samovar/scanner.py,sha256=V9bYcY0n_oFUqk87SBBToE-XtTALcXtmE3RmiZoab_s,3575
+samovar/terms.py,sha256=aYTEJynkCu_ecDm7WpETT_XSBl-Wl4JPEV7unn5AqDE,3360
+samovar/tests.py,sha256=T-clqS77aRloIt5tkm56ffeY05oYIB0JUeUWyjqMUj8,7017
+samovar/generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+samovar/generators/base.py,sha256=-oeffjcGkVyDr0ltIY9W0OUQrG84LYbqJWZiWTkQ4Qk,1799
+samovar/generators/breadthfirst.py,sha256=JA9ZcGA6Nj0YM8f5QQPVgL04l-uCmfE6ntlo65B25B8,2181
+samovar/generators/depthfirst.py,sha256=7HfkMKb0RUiObC2Y9nzY7U2bg7z33Vtcx1dKhGVv4d4,2605
+samovar/generators/stochastic.py,sha256=6ca1OjpjocCBInq81tuKv_HLBgbLwgN_cZhaSrizbw0,2218
+samovar_py-0.6.dist-info/METADATA,sha256=tf1Z8B5hHVEi51MECtnajfjbse8st1lHVIxqXOEEC0I,5656
+samovar_py-0.6.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
+samovar_py-0.6.dist-info/entry_points.txt,sha256=tpU5DZJ34s4hpNFCobyu6E-SdWQyxfQBy_-oMZFqMxk,50
+samovar_py-0.6.dist-info/top_level.txt,sha256=78kn4qDuoyXOHtnHgEl6PtZaxBAQ7Basrn2mBbW8i_Y,8
+samovar_py-0.6.dist-info/RECORD,,

samovar_py-0.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

samovar_py-0.6.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+samovar = samovar.main:sys_main

samovar_py-0.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+samovar