signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def __setitem__(self, key, val):
|
created = key not in self<EOL>if key not in self._cache:<EOL><INDENT>self._cache[key] = self.Predecessors(self, key)<EOL><DEDENT>preds = self._cache[key]<EOL>preds.clear()<EOL>preds.update(val)<EOL>if created:<EOL><INDENT>self.send(self, key=key, val=val)<EOL><DEDENT>
|
Interpret ``val`` as a mapping of edges that end at ``dest``
|
f9015:c11:m2
|
def __delitem__(self, key):
|
it = self[key]<EOL>it.clear()<EOL>del self._cache[key]<EOL>self.send(self, key=key, val=None)<EOL>
|
Delete all edges ending at ``dest``
|
f9015:c11:m3
|
def _order_nodes(self):
|
raise NotImplemented<EOL>
|
Swap my orig and dest if desired
|
f9015:c12:m0
|
def __len__(self):
|
n = <NUM_LIT:0><EOL>for idx in iter(self):<EOL><INDENT>n += <NUM_LIT:1><EOL><DEDENT>return n<EOL>
|
How many edges currently connect my two nodes?
|
f9015:c12:m3
|
def __getitem__(self, idx):
|
if idx not in self:<EOL><INDENT>raise KeyError("<STR_LIT>")<EOL><DEDENT>return self._getedge(idx)<EOL>
|
Get an Edge with a particular index, if it exists at the present
(branch, rev)
|
f9015:c12:m6
|
def __setitem__(self, idx, val):
|
orig, dest = self._order_nodes()<EOL>created = idx not in self<EOL>if orig not in self.graph.node:<EOL><INDENT>self.graph.add_node(orig)<EOL><DEDENT>if dest not in self.graph.node:<EOL><INDENT>self.graph.add_node(dest)<EOL><DEDENT>branch, turn, tick = self.db._nbtt()<EOL>self.db.query.exist_edge(<EOL>self.graph.name,<EOL>orig,<EOL>dest,<EOL>idx,<EOL>branch, turn, tick,<EOL>True<EOL>)<EOL>self.db._edges_cache.store(<EOL>self.graph.name, orig, dest, idx,<EOL>branch, turn, tick, True<EOL>)<EOL>e = self._getedge(idx)<EOL>e.clear()<EOL>e.update(val)<EOL>if created:<EOL><INDENT>self.send(self, orig=orig, dest=dest, idx=idx, exists=True)<EOL><DEDENT>
|
Create an Edge at a given index from a mapping. Delete the existing
Edge first, if necessary.
|
f9015:c12:m7
|
def __delitem__(self, idx):
|
branch, turn, tick = self.db._btt()<EOL>orig, dest = self._order_nodes()<EOL>tick += <NUM_LIT:1><EOL>e = self._getedge(idx)<EOL>e.clear()<EOL>if idx in self._cache:<EOL><INDENT>del self._cache[idx]<EOL><DEDENT>self.db._edges_cache.store(<EOL>self.graph.name, orig, dest, idx,<EOL>branch, turn, tick, None<EOL>)<EOL>self.db.tick = tick<EOL>self.send(self, orig=orig, dest=dest, idx=idx, exists=False)<EOL>
|
Delete the edge at a particular index
|
f9015:c12:m8
|
def clear(self):
|
for idx in self:<EOL><INDENT>del self[idx]<EOL><DEDENT>
|
Delete all edges between these nodes
|
f9015:c12:m9
|
def __getitem__(self, orig):
|
if orig not in self.graph.node:<EOL><INDENT>raise KeyError("<STR_LIT>")<EOL><DEDENT>return self._getsucc(orig)<EOL>
|
If the node exists, return its Successors
|
f9015:c13:m0
|
def __setitem__(self, orig, val):
|
r = self._getsucc(orig)<EOL>r.clear()<EOL>r.update(val)<EOL>self.send(self, key=orig, val=val)<EOL>
|
Interpret ``val`` as a mapping of successors, and turn it into a
proper Successors object for storage
|
f9015:c13:m2
|
def __delitem__(self, orig):
|
succs = self._getsucc(orig)<EOL>succs.clear()<EOL>del self._cache[orig]<EOL>self.send(self, key=orig, val=None)<EOL>
|
Disconnect this node from everything
|
f9015:c13:m3
|
def _and_previous(self):
|
branch = self.db.branch<EOL>rev = self.db.rev<EOL>(parent, parent_rev) = self.db.sql('<STR_LIT>', branch).fetchone()<EOL>before_branch = parent if parent_rev == rev else branch<EOL>return (before_branch, rev-<NUM_LIT:1>, branch, rev)<EOL>
|
Return a 4-tuple that will usually be (current branch, current
revision - 1, current branch, current revision), unless
current revision - 1 is before the start of the current
branch, in which case the first element will be the parent
branch.
|
f9015:c16:m12
|
def clear(self):
|
self.adj.clear()<EOL>self.node.clear()<EOL>self.graph.clear()<EOL>
|
Remove all nodes and edges from the graph.
Unlike the regular networkx implementation, this does *not*
remove the graph's name. But all the other graph, node, and
edge attributes go away.
|
f9015:c16:m13
|
def remove_edge(self, u, v):
|
try:<EOL><INDENT>del self.succ[u][v]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise NetworkXError(<EOL>"<STR_LIT>".format(u, v)<EOL>)<EOL><DEDENT>
|
Version of remove_edge that's much like normal networkx but only
deletes once, since the database doesn't keep separate adj and
succ mappings
|
f9015:c18:m0
|
def remove_edges_from(self, ebunch):
|
for e in ebunch:<EOL><INDENT>(u, v) = e[:<NUM_LIT:2>]<EOL>if u in self.succ and v in self.succ[u]:<EOL><INDENT>del self.succ[u][v]<EOL><DEDENT><DEDENT>
|
Version of remove_edges_from that's much like normal networkx but only
deletes once, since the database doesn't keep separate adj and
succ mappings
|
f9015:c18:m1
|
def add_edge(self, u, v, attr_dict=None, **attr):
|
if attr_dict is None:<EOL><INDENT>attr_dict = attr<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>attr_dict.update(attr)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise NetworkXError(<EOL>"<STR_LIT>"<EOL>)<EOL><DEDENT><DEDENT>if u not in self.node:<EOL><INDENT>self.node[u] = {}<EOL><DEDENT>if v not in self.node:<EOL><INDENT>self.node[v] = {}<EOL><DEDENT>if u in self.adj:<EOL><INDENT>datadict = self.adj[u].get(v, {})<EOL><DEDENT>else:<EOL><INDENT>self.adj[u] = {v: {}}<EOL>datadict = self.adj[u][v]<EOL><DEDENT>datadict.update(attr_dict)<EOL>self.succ[u][v] = datadict<EOL>assert u in self.succ, "<STR_LIT>".format(u=u, v=v)<EOL>assert v in self.succ[u], "<STR_LIT>".format(u=u, v=v)<EOL>
|
Version of add_edge that only writes to the database once
|
f9015:c18:m2
|
def add_edges_from(self, ebunch, attr_dict=None, **attr):
|
if attr_dict is None:<EOL><INDENT>attr_dict = attr<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>attr_dict.update(attr)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise NetworkXError(<EOL>"<STR_LIT>"<EOL>)<EOL><DEDENT><DEDENT>for e in ebunch:<EOL><INDENT>ne = len(e)<EOL>if ne == <NUM_LIT:3>:<EOL><INDENT>u, v, dd = e<EOL>assert hasattr(dd, "<STR_LIT>")<EOL><DEDENT>elif ne == <NUM_LIT:2>:<EOL><INDENT>u, v = e<EOL>dd = {}<EOL><DEDENT>else:<EOL><INDENT>raise NetworkXError(<EOL>"<STR_LIT>".format(e)<EOL>)<EOL><DEDENT>if u not in self.node:<EOL><INDENT>self.node[u] = {}<EOL><DEDENT>if v not in self.node:<EOL><INDENT>self.node[v] = {}<EOL><DEDENT>datadict = self.adj.get(u, {}).get(v, {})<EOL>datadict.update(attr_dict)<EOL>datadict.update(dd)<EOL>self.succ[u][v] = datadict<EOL>assert(u in self.succ)<EOL>assert(v in self.succ[u])<EOL><DEDENT>
|
Version of add_edges_from that only writes to the database once
|
f9015:c18:m3
|
def remove_edge(self, u, v, key=None):
|
try:<EOL><INDENT>d = self.adj[u][v]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise NetworkXError(<EOL>"<STR_LIT>".format(u, v)<EOL>)<EOL><DEDENT>if key is None:<EOL><INDENT>d.popitem()<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>del d[key]<EOL><DEDENT>except KeyError:<EOL><INDENT>raise NetworkXError(<EOL>"<STR_LIT>".format<EOL>(u, v, key)<EOL>)<EOL><DEDENT><DEDENT>if len(d) == <NUM_LIT:0>:<EOL><INDENT>del self.succ[u][v]<EOL><DEDENT>
|
Version of remove_edge that's much like normal networkx but only
deletes once, since the database doesn't keep separate adj and
succ mappings
|
f9015:c20:m0
|
def remove_edges_from(self, ebunch):
|
for e in ebunch:<EOL><INDENT>(u, v) = e[:<NUM_LIT:2>]<EOL>if u in self.succ and v in self.succ[u]:<EOL><INDENT>del self.succ[u][v]<EOL><DEDENT><DEDENT>
|
Version of remove_edges_from that's much like normal networkx but only
deletes once, since the database doesn't keep separate adj and
succ mappings
|
f9015:c20:m1
|
def add_edge(self, u, v, key=None, attr_dict=None, **attr):
|
if attr_dict is None:<EOL><INDENT>attr_dict = attr<EOL><DEDENT>else:<EOL><INDENT>try:<EOL><INDENT>attr_dict.update(attr)<EOL><DEDENT>except AttributeError:<EOL><INDENT>raise NetworkXError(<EOL>"<STR_LIT>"<EOL>)<EOL><DEDENT><DEDENT>if u not in self.node:<EOL><INDENT>self.node[u] = {}<EOL><DEDENT>if v not in self.node:<EOL><INDENT>self.node[v] = {}<EOL><DEDENT>if v in self.succ[u]:<EOL><INDENT>keydict = self.adj[u][v]<EOL>if key is None:<EOL><INDENT>key = len(keydict)<EOL>while key in keydict:<EOL><INDENT>key += <NUM_LIT:1><EOL><DEDENT><DEDENT>datadict = keydict.get(key, {})<EOL>datadict.update(attr_dict)<EOL>keydict[key] = datadict<EOL><DEDENT>else:<EOL><INDENT>if key is None:<EOL><INDENT>key = <NUM_LIT:0><EOL><DEDENT>datadict = {}<EOL>datadict.update(attr_dict)<EOL>keydict = {key: datadict}<EOL>self.succ[u][v] = keydict<EOL><DEDENT>return key<EOL>
|
Version of add_edge that only writes to the database once.
|
f9015:c20:m2
|
def getatt(attribute_name):
|
return property(attrgetter(attribute_name))<EOL>
|
An easy way to make an alias
|
f9018:m0
|
def singleton_get(s):
|
it = None<EOL>for that in s:<EOL><INDENT>if it is not None:<EOL><INDENT>return None<EOL><DEDENT>it = that<EOL><DEDENT>return it<EOL>
|
Take an iterable and return its only item if possible, else None.
|
f9018:m1
|
def sort_set(s):
|
if not isinstance(s, Set):<EOL><INDENT>raise TypeError("<STR_LIT>")<EOL><DEDENT>s = frozenset(s)<EOL>if s not in _sort_set_memo:<EOL><INDENT>_sort_set_memo[s] = sorted(s, key=_sort_set_key)<EOL><DEDENT>return _sort_set_memo[s]<EOL>
|
Return a sorted list of the contents of a set
This is intended to be used to iterate over world state, where you just need keys
to be in some deterministic order, but the sort order should be obvious from the key.
Non-strings come before strings and then tuples. Tuples compare element-wise as normal.
But ultimately all comparisons are between values' ``repr``.
This is memoized.
|
f9018:m4
|
def tables_for_meta(meta):
|
allegedb.alchemy.tables_for_meta(meta)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT:key>', TEXT, primary_key=True),<EOL>Column(<EOL>'<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'<EOL>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT:value>', TEXT)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', TEXT, default='<STR_LIT>')<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', TEXT, default='<STR_LIT>'),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>'], ['<STR_LIT>']<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', TEXT, default='<STR_LIT>'),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>'], ['<STR_LIT>']<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', TEXT, default='<STR_LIT>'),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>'], ['<STR_LIT>']<EOL>)<EOL>)<EOL>for name in (<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>):<EOL><INDENT>Table(<EOL>name, meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', TEXT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>'], ['<STR_LIT>']<EOL>),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>'], ['<STR_LIT>']<EOL>)<EOL>)<EOL><DEDENT>nrh = Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>'], ['<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT),<EOL>Column('<STR_LIT>', INT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>[nrh.c.character, nrh.c.node, nrh.c.rulebook, nrh.c.rule, nrh.c.branch, nrh.c.turn]<EOL>)<EOL>)<EOL>porh = Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT),<EOL>Column('<STR_LIT>', INT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>[porh.c.character, porh.c.orig, porh.c.dest, porh.c.rulebook, porh.c.rule, porh.c.branch, porh.c.turn]<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column(<EOL>'<STR_LIT>', TEXT, primary_key=True, nullable=True<EOL>),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column(<EOL>'<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'<EOL>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', TEXT, nullable=True),<EOL>ForeignKeyConstraint(['<STR_LIT>'], ['<STR_LIT>'])<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column(<EOL>'<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'<EOL>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT:location>', TEXT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>'], ['<STR_LIT>', '<STR_LIT>']<EOL>),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT:location>'], ['<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', TEXT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>'], ['<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', TEXT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column(<EOL>'<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'<EOL>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', INT, primary_key=True, default=<NUM_LIT:0>),<EOL>Column('<STR_LIT>', BOOLEAN),<EOL>ForeignKeyConstraint(['<STR_LIT>'], ['<STR_LIT>']),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>'],<EOL>['<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>)<EOL>crh = Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', INT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>'], ['<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT),<EOL>Column('<STR_LIT>', TEXT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>[crh.c.character, crh.c.rulebook, crh.c.rule, crh.c.branch, crh.c.turn]<EOL>)<EOL>)<EOL>arh = Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', INT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>'], ['<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT),<EOL>Column('<STR_LIT>', TEXT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>[arh.c.character, arh.c.rulebook, arh.c.rule, arh.c.graph, arh.c.avatar, arh.c.branch, arh.c.turn]<EOL>)<EOL>)<EOL>ctrh = Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', INT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>'], ['<STR_LIT>', '<STR_LIT>']<EOL>),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>'], ['<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT),<EOL>Column('<STR_LIT>', INT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>[ctrh.c.character, ctrh.c.rulebook, ctrh.c.rule, ctrh.c.thing, ctrh.c.branch, ctrh.c.turn]<EOL>)<EOL>)<EOL>cprh = Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', INT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>'], ['<STR_LIT>', '<STR_LIT>']<EOL>),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>'], ['<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT),<EOL>Column('<STR_LIT>', INT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>[cprh.c.character, cprh.c.rulebook, cprh.c.rule, cprh.c.place, cprh.c.branch, cprh.c.turn]<EOL>)<EOL>)<EOL>cporh = Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True, default='<STR_LIT>'),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', INT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>'], ['<STR_LIT>', '<STR_LIT>']<EOL>),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>'], ['<STR_LIT>', '<STR_LIT>', '<STR_LIT>']<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', INT, primary_key=True),<EOL>Column('<STR_LIT>', TEXT),<EOL>Column('<STR_LIT>', INT),<EOL>ForeignKeyConstraint(<EOL>['<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>', '<STR_LIT>'],<EOL>[cporh.c.character, cporh.c.rulebook, cporh.c.rule, cporh.c.orig, cporh.c.dest, cporh.c.branch, cporh.c.turn]<EOL>)<EOL>)<EOL>Table(<EOL>'<STR_LIT>', meta,<EOL>Column('<STR_LIT>', TEXT, primary_key=True),<EOL>Column('<STR_LIT>', INT)<EOL>)<EOL>return meta.tables<EOL>
|
Return a dictionary full of all the tables I need for LiSE. Use the
provided metadata object.
|
f9019:m0
|
def queries(table):
|
def update_where(updcols, wherecols):<EOL><INDENT>"""<STR_LIT>"""<EOL>vmap = OrderedDict()<EOL>for col in updcols:<EOL><INDENT>vmap[col] = bindparam(col)<EOL><DEDENT>wheres = [<EOL>c == bindparam(c.name) for c in wherecols<EOL>]<EOL>tab = wherecols[<NUM_LIT:0>].table<EOL>return tab.update().values(**vmap).where(and_(*wheres))<EOL><DEDENT>r = allegedb.alchemy.queries_for_table_dict(table)<EOL>rulebooks = table['<STR_LIT>']<EOL>r['<STR_LIT>'] = update_where(['<STR_LIT>'], [rulebooks.c.rulebook, rulebooks.c.branch, rulebooks.c.turn, rulebooks.c.tick])<EOL>for t in table.values():<EOL><INDENT>key = list(t.primary_key)<EOL>if '<STR_LIT>' in t.columns and '<STR_LIT>' in t.columns and '<STR_LIT>' in t.columns:<EOL><INDENT>branch = t.columns['<STR_LIT>']<EOL>turn = t.columns['<STR_LIT>']<EOL>tick = t.columns['<STR_LIT>']<EOL>if branch in key and turn in key and tick in key:<EOL><INDENT>key = [branch, turn, tick]<EOL><DEDENT><DEDENT>r[t.name + '<STR_LIT>'] = select(list(t.c.values())).order_by(*key)<EOL>r[t.name + '<STR_LIT>'] = t.insert().values(tuple(bindparam(cname) for cname in t.c.keys()))<EOL>r[t.name + '<STR_LIT>'] = select([func.COUNT('<STR_LIT:*>')]).select_from(t)<EOL><DEDENT>r['<STR_LIT>'] = table['<STR_LIT>'].delete().where(<EOL>table['<STR_LIT>'].c.character == bindparam('<STR_LIT>')<EOL>)<EOL>r['<STR_LIT>'] = table['<STR_LIT>'].delete().where(<EOL>table['<STR_LIT>'].c.character_graph == bindparam('<STR_LIT>')<EOL>)<EOL>things = table['<STR_LIT>']<EOL>r['<STR_LIT>'] = things.delete().where(and_(<EOL>things.c.character == bindparam('<STR_LIT>'),<EOL>things.c.thing == bindparam('<STR_LIT>'),<EOL>things.c.branch == bindparam('<STR_LIT>'),<EOL>or_(<EOL>things.c.turn > bindparam('<STR_LIT>'),<EOL>and_(<EOL>things.c.turn == bindparam('<STR_LIT>'),<EOL>things.c.tick >= bindparam('<STR_LIT>')<EOL>)<EOL>)<EOL>))<EOL>avatars = table['<STR_LIT>']<EOL>r['<STR_LIT>'] = avatars.delete().where(and_(<EOL>avatars.c.character_graph == bindparam('<STR_LIT>'),<EOL>avatars.c.avatar_graph == bindparam('<STR_LIT>'),<EOL>avatars.c.avatar_node == bindparam('<STR_LIT>'),<EOL>avatars.c.branch == bindparam('<STR_LIT>'),<EOL>or_(<EOL>avatars.c.turn > bindparam('<STR_LIT>'),<EOL>and_(<EOL>avatars.c.turn == bindparam('<STR_LIT>'),<EOL>avatars.c.tick >= bindparam('<STR_LIT>')<EOL>)<EOL>)<EOL>))<EOL>branches = table['<STR_LIT>']<EOL>r['<STR_LIT>'] = select(<EOL>[branches.c.branch]<EOL>).where(<EOL>branches.c.parent == bindparam('<STR_LIT>')<EOL>)<EOL>tc = table['<STR_LIT>']<EOL>r['<STR_LIT>'] = update_where(['<STR_LIT>'], [tc.c.branch])<EOL>return r<EOL>
|
Given dictionaries of tables and view-queries, return a dictionary
of all the rest of the queries I need.
|
f9019:m2
|
def dict_delta(old, new):
|
r = {}<EOL>oldkeys = set(old.keys())<EOL>newkeys = set(new.keys())<EOL>r.update((k, new[k]) for k in newkeys.difference(oldkeys))<EOL>r.update((k, None) for k in oldkeys.difference(newkeys))<EOL>for k in oldkeys.intersection(newkeys):<EOL><INDENT>if old[k] != new[k]:<EOL><INDENT>r[k] = new[k]<EOL><DEDENT><DEDENT>return r<EOL>
|
Return a dictionary containing the items of ``new`` that are either
absent from ``old`` or whose values are different; as well as the
value ``None`` for those keys that are present in ``old``, but
absent from ``new``.
Useful for describing changes between two versions of a dict.
|
f9020:m0
|
def __init__(self, args, kwargs={}, logq=None, logfile=None, loglevel=None):
|
kwargs.setdefault('<STR_LIT>', self.log)<EOL>self._real = Engine(*args, **kwargs)<EOL>self._logq = logq<EOL>self._loglevel = loglevel<EOL>self._muted_chars = set()<EOL>self.branch = self._real.branch<EOL>self.turn = self._real.turn<EOL>self.tick = self._real.tick<EOL>self._node_stat_cache = defaultdict(dict)<EOL>self._portal_stat_cache = defaultdict(<EOL>lambda: defaultdict(dict)<EOL>)<EOL>self._char_stat_cache = {}<EOL>self._char_av_cache = defaultdict(lambda: defaultdict(set))<EOL>self._char_rulebooks_cache = {}<EOL>self._char_nodes_rulebooks_cache = defaultdict(dict)<EOL>self._char_portals_rulebooks_cache = defaultdict(<EOL>lambda: defaultdict(dict)<EOL>)<EOL>self._char_nodes_cache = {}<EOL>self._char_portals_cache = {}<EOL>self._node_successors_cache = defaultdict(dict)<EOL>self._strings_cache = {}<EOL>self._eternal_cache = {}<EOL>self._universal_cache = {}<EOL>self._rule_cache = {}<EOL>self._rulebook_cache = defaultdict(list)<EOL>self._stores_cache = defaultdict(dict)<EOL>
|
Instantiate an engine with the positional arguments ``args`` and
the keyword arguments ``kwargs``.
``logq`` is a :class:`Queue` into which I'll put tuples of
``(loglevel, message)``.
|
f9020:c0:m0
|
def character_copy(self, char):
|
ret = self.character_stat_copy(char)<EOL>chara = self._real.character[char]<EOL>nv = self.character_nodes_stat_copy(char)<EOL>if nv:<EOL><INDENT>ret['<STR_LIT>'] = nv<EOL><DEDENT>ev = self.character_portals_stat_copy(char)<EOL>if ev:<EOL><INDENT>ret['<STR_LIT>'] = ev<EOL><DEDENT>avs = self.character_avatars_copy(char)<EOL>if avs:<EOL><INDENT>ret['<STR_LIT>'] = avs<EOL><DEDENT>rbs = self.character_rulebooks_copy(char)<EOL>if rbs:<EOL><INDENT>ret['<STR_LIT>'] = rbs<EOL><DEDENT>nrbs = self.character_nodes_rulebooks_copy(char)<EOL>if nrbs:<EOL><INDENT>for node, rb in nrbs.items():<EOL><INDENT>assert node in chara.node<EOL>if '<STR_LIT>' not in ret:<EOL><INDENT>ret['<STR_LIT>'] = {}<EOL><DEDENT>nv = ret['<STR_LIT>']<EOL>if node not in nv:<EOL><INDENT>nv[node] = {}<EOL><DEDENT>nv[node]['<STR_LIT>'] = rb<EOL><DEDENT><DEDENT>porbs = self.character_portals_rulebooks_copy(char)<EOL>if porbs:<EOL><INDENT>for orig, dests in porbs.items():<EOL><INDENT>ports = chara.portal[orig]<EOL>for dest, rb in dests.items():<EOL><INDENT>assert dest in ports<EOL>if '<STR_LIT>' not in ret:<EOL><INDENT>ret['<STR_LIT>'] = {}<EOL><DEDENT>ev = ret['<STR_LIT>']<EOL>if orig not in ev:<EOL><INDENT>ev[orig] = {}<EOL><DEDENT>ov = ev[orig]<EOL>if dest not in ov:<EOL><INDENT>ov[dest] = {}<EOL><DEDENT>ov[dest]['<STR_LIT>'] = rb<EOL><DEDENT><DEDENT><DEDENT>return ret<EOL>
|
Return a dictionary describing character ``char``.
|
f9020:c0:m62
|
def character_delta(self, char, *, store=True):
|
ret = self.character_stat_delta(char, store=store)<EOL>nodes = self.character_nodes_delta(char, store=store)<EOL>chara = self._real.character[char]<EOL>if nodes:<EOL><INDENT>ret['<STR_LIT>'] = nodes<EOL><DEDENT>edges = self.character_portals_delta(char, store=store)<EOL>if edges:<EOL><INDENT>ret['<STR_LIT>'] = edges<EOL><DEDENT>avs = self.character_avatars_delta(char, store=store)<EOL>if avs:<EOL><INDENT>ret['<STR_LIT>'] = avs<EOL><DEDENT>rbs = self.character_rulebooks_delta(char, store=store)<EOL>if rbs:<EOL><INDENT>ret['<STR_LIT>'] = rbs<EOL><DEDENT>nrbs = self.character_nodes_rulebooks_delta(char, store=store)<EOL>if nrbs:<EOL><INDENT>for node, rb in nrbs.items():<EOL><INDENT>if node not in chara.node:<EOL><INDENT>continue<EOL><DEDENT>ret.setdefault('<STR_LIT>', {}).setdefault(node, {})['<STR_LIT>'] = rb<EOL><DEDENT><DEDENT>porbs = self.character_portals_rulebooks_delta(char, store=store)<EOL>if porbs:<EOL><INDENT>for orig, dests in porbs.items():<EOL><INDENT>if orig not in chara.portal:<EOL><INDENT>continue<EOL><DEDENT>portals = chara.portal[orig]<EOL>for dest, rb in dests.items():<EOL><INDENT>if dest not in portals:<EOL><INDENT>continue<EOL><DEDENT>ret.setdefault('<STR_LIT>', {}).setdefault(orig, {}).setdefault(dest, {})['<STR_LIT>'] = rb<EOL><DEDENT><DEDENT><DEDENT>nv = self.character_nodes_stat_delta(char, store=store)<EOL>if nv:<EOL><INDENT>ret['<STR_LIT>'] = nv<EOL><DEDENT>ev = self.character_portals_stat_delta(char, store=store)<EOL>if ev:<EOL><INDENT>ret['<STR_LIT>'] = ev<EOL><DEDENT>return ret<EOL>
|
Return a dictionary of changes to ``char`` since previous call.
|
f9020:c0:m63
|
def node_stat_copy(self, node_or_char, node=None):
|
if node is None:<EOL><INDENT>node = node_or_char<EOL><DEDENT>else:<EOL><INDENT>node = self._real.character[node_or_char].node[node]<EOL><DEDENT>return {<EOL>k: v.unwrap() if hasattr(v, '<STR_LIT>') and not hasattr(v, '<STR_LIT>') else v<EOL>for (k, v) in node.items() if k not in {<EOL>'<STR_LIT>',<EOL>'<STR_LIT:name>',<EOL>'<STR_LIT>',<EOL>'<STR_LIT>'<EOL>}<EOL>}<EOL>
|
Return a node's stats, prepared for pickling, in a dictionary.
|
f9020:c0:m72
|
def node_stat_delta(self, char, node, *, store=True):
|
try:<EOL><INDENT>old = self._node_stat_cache[char].get(node, {})<EOL>new = self.node_stat_copy(self._real.character[char].node[node])<EOL>if store:<EOL><INDENT>self._node_stat_cache[char][node] = new<EOL><DEDENT>r = dict_delta(old, new)<EOL>return r<EOL><DEDENT>except KeyError:<EOL><INDENT>return None<EOL><DEDENT>
|
Return a dictionary describing changes to a node's stats since the
last time you looked at it.
Deleted keys have the value ``None``. If the node's been deleted, this
returns ``None``.
|
f9020:c0:m73
|
def character_nodes_stat_delta(self, char, *, store=True):
|
r = {}<EOL>nodes = set(self._real.character[char].node.keys())<EOL>for node in nodes:<EOL><INDENT>delta = self.node_stat_delta(char, node, store=store)<EOL>if delta:<EOL><INDENT>r[node] = delta<EOL><DEDENT><DEDENT>nsc = self._node_stat_cache[char]<EOL>for node in list(nsc.keys()):<EOL><INDENT>if node not in nodes:<EOL><INDENT>del nsc[node]<EOL><DEDENT><DEDENT>return r<EOL>
|
Return a dictionary of ``node_stat_delta`` output for each node in a
character.
|
f9020:c0:m74
|
@timely<EOL><INDENT>def update_node(self, char, node, patch):<DEDENT>
|
character = self._real.character[char]<EOL>if patch is None:<EOL><INDENT>del character.node[node]<EOL><DEDENT>elif node not in character.node:<EOL><INDENT>character.node[node] = patch<EOL>return<EOL><DEDENT>else:<EOL><INDENT>character.node[node].update(patch)<EOL><DEDENT>
|
Change a node's stats according to a dictionary.
The ``patch`` dictionary should hold the new values of stats,
keyed by the stats' names; a value of ``None`` deletes the
stat.
|
f9020:c0:m76
|
@timely<EOL><INDENT>def update_nodes(self, char, patch, backdate=False):<DEDENT>
|
if backdate:<EOL><INDENT>parbranch, parrev = self._real._parentbranch_rev.get(<EOL>self._real.branch, ('<STR_LIT>', <NUM_LIT:0>)<EOL>)<EOL>tick_now = self._real.tick<EOL>self._real.tick = parrev<EOL><DEDENT>for i, (n, npatch) in enumerate(patch.items(), <NUM_LIT:1>):<EOL><INDENT>self.update_node(char, n, npatch)<EOL><DEDENT>if backdate:<EOL><INDENT>self._real.tick = tick_now<EOL><DEDENT>
|
Change the stats of nodes in a character according to a
dictionary.
|
f9020:c0:m77
|
@timely<EOL><INDENT>def del_node(self, char, node):<DEDENT>
|
del self._real.character[char].node[node]<EOL>for cache in (<EOL>self._char_nodes_rulebooks_cache,<EOL>self._node_stat_cache,<EOL>self._node_successors_cache<EOL>):<EOL><INDENT>try:<EOL><INDENT>del cache[char][node]<EOL><DEDENT>except KeyError:<EOL><INDENT>pass<EOL><DEDENT><DEDENT>if char in self._char_nodes_cache and node in self._char_nodes_cache[char]:<EOL><INDENT>self._char_nodes_cache[char] = self._char_nodes_cache[char] - frozenset([node])<EOL><DEDENT>if char in self._portal_stat_cache:<EOL><INDENT>portal_stat_cache_char = self._portal_stat_cache[char]<EOL>if node in portal_stat_cache_char:<EOL><INDENT>del portal_stat_cache_char[node]<EOL><DEDENT>for charo in portal_stat_cache_char.values():<EOL><INDENT>if node in charo:<EOL><INDENT>del charo[node]<EOL><DEDENT><DEDENT><DEDENT>if char in self._char_portals_rulebooks_cache:<EOL><INDENT>portal_rulebook_cache_char = self._char_portals_rulebooks_cache[char]<EOL>if node in portal_rulebook_cache_char:<EOL><INDENT>del portal_rulebook_cache_char[node]<EOL><DEDENT>for porto in portal_rulebook_cache_char.values():<EOL><INDENT>if node in porto:<EOL><INDENT>del porto[node]<EOL><DEDENT><DEDENT><DEDENT>
|
Remove a node from a character.
|
f9020:c0:m78
|
@timely<EOL><INDENT>def thing_travel_to(self, char, thing, dest, weight=None, graph=None):<DEDENT>
|
return self._real.character[char].thing[thing].travel_to(dest, weight, graph)<EOL>
|
Make something find a path to ``dest`` and follow it.
Optional argument ``weight`` is the portal stat to use to schedule movement times.
Optional argument ``graph`` is an alternative graph to use for pathfinding.
Should resemble a networkx DiGraph.
|
f9020:c0:m99
|
def patch(self, patch):
|
self.engine.handle(<EOL>'<STR_LIT>',<EOL>char=self.character.name,<EOL>patch=patch,<EOL>block=False<EOL>)<EOL>for node, stats in patch.items():<EOL><INDENT>nodeproxycache = self[node]._cache<EOL>for k, v in stats.items():<EOL><INDENT>if v is None:<EOL><INDENT>del nodeproxycache[k]<EOL><DEDENT>else:<EOL><INDENT>nodeproxycache[k] = v<EOL><DEDENT><DEDENT><DEDENT>
|
Change a bunch of node stats at once.
This works similarly to ``update``, but only accepts a dict-like argument,
and it recurses one level.
The patch is sent to the LiSE core all at once, so this is faster than
using ``update``, too.
:param patch: a dictionary. Keys are node names, values are other dicts
describing updates to the nodes, where a value of None means delete the stat.
Other values overwrite.
|
f9021:c9:m11
|
def handle(self, cmd=None, **kwargs):
|
if '<STR_LIT>' in kwargs:<EOL><INDENT>cmd = kwargs['<STR_LIT>']<EOL><DEDENT>elif cmd:<EOL><INDENT>kwargs['<STR_LIT>'] = cmd<EOL><DEDENT>else:<EOL><INDENT>raise TypeError("<STR_LIT>")<EOL><DEDENT>branching = kwargs.get('<STR_LIT>', False)<EOL>cb = kwargs.pop('<STR_LIT>', None)<EOL>future = kwargs.pop('<STR_LIT>', False)<EOL>self._handle_lock.acquire()<EOL>if kwargs.pop('<STR_LIT>', True):<EOL><INDENT>assert not kwargs.get('<STR_LIT>')<EOL>self.debug('<STR_LIT>'.format(kwargs))<EOL>self.send(self.pack(kwargs))<EOL>command, branch, turn, tick, result = self.recv()<EOL>assert cmd == command,"<STR_LIT>".format(<EOL>cmd, command<EOL>)<EOL>r = self.unpack(result)<EOL>self.debug('<STR_LIT>'.format((command, branch, turn, tick, r)))<EOL>if (branch, turn, tick) != self._btt():<EOL><INDENT>self._branch = branch<EOL>self._turn = turn<EOL>self._tick = tick<EOL>self.time.send(self, branch=branch, turn=turn, tick=tick)<EOL><DEDENT>if isinstance(r, Exception):<EOL><INDENT>self._handle_lock.release()<EOL>raise r<EOL><DEDENT>if cb:<EOL><INDENT>cb(command=command, branch=branch, turn=turn, tick=tick, result=r)<EOL><DEDENT>self._handle_lock.release()<EOL>return r<EOL><DEDENT>else:<EOL><INDENT>kwargs['<STR_LIT>'] = not (branching or cb or future)<EOL>self.debug('<STR_LIT>'.format(kwargs))<EOL>self.send(self.pack(kwargs))<EOL>if branching:<EOL><INDENT>return self._submit(self._branching, cb)<EOL><DEDENT>elif cb:<EOL><INDENT>return self._submit(self._callback, cb)<EOL><DEDENT>if future:<EOL><INDENT>return self._submit(self._unpack_recv)<EOL><DEDENT><DEDENT>self._handle_lock.release()<EOL>
|
Send a command to the LiSE core.
The only positional argument should be the name of a
method in :class:``EngineHandle``. All keyword arguments
will be passed to it, with the exceptions of
``cb``, ``branching``, and ``silent``.
With ``block=False``, don't wait for a result.
This is best for when you want to make some change to the game
state and already know what effect it will have.
With ``branching=True``, handle paradoxes by creating new
branches of history. I will switch to the new branch if needed.
If I have an attribute ``branching_cb``, I'll call it if and
only if the branch changes upon completing a command with
``branching=True``.
With a function ``cb``, I will call ``cb`` when I get
a result. If ``block=False`` this will happen in a thread.
``cb`` will be called with keyword arguments ``command``,
the same command you asked for; ``result``, the value returned
by it, possibly ``None``; and the present ``branch``,
``turn``, and ``tick``, possibly different than when you called
``handle``.
If any of ``branching``, ``cb``, or ``future`` are ``True``,
I will return a ``Future``. The ``Future``'s return value
is a tuple of ``(command, branch, turn, tick, result)``.
|
f9021:c35:m13
|
def pull(self, chars='<STR_LIT:all>', cb=None, block=True):
|
if block:<EOL><INDENT>deltas = self.handle('<STR_LIT>', chars=chars)<EOL>self._upd_caches(deltas)<EOL>if cb:<EOL><INDENT>cb(deltas)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>return self._submit(self._pull_async, chars, cb)<EOL><DEDENT>
|
Update the state of all my proxy objects from the real objects.
|
f9021:c35:m23
|
def time_travel(self, branch, turn, tick=None, chars='<STR_LIT:all>', cb=None, block=True):
|
if cb and not chars:<EOL><INDENT>raise TypeError("<STR_LIT>")<EOL><DEDENT>if cb is not None and not callable(cb):<EOL><INDENT>raise TypeError("<STR_LIT>")<EOL><DEDENT>return self.handle(<EOL>'<STR_LIT>',<EOL>block=block,<EOL>branch=branch,<EOL>turn=turn,<EOL>tick=tick,<EOL>chars=chars,<EOL>cb=partial(self._upd_and_cb, cb)<EOL>)<EOL>
|
Move to a different point in the timestream.
Needs ``branch`` and ``turn`` arguments. The ``tick`` is optional; if unspecified,
you'll travel to the last tick in the turn.
May take a callback function ``cb``, which will receive a dictionary describing
changes to the characters in ``chars``. ``chars`` defaults to 'all', indicating
that every character should be included, but may be a list of character names
to include.
With ``block=True`` (the default), wait until finished computing differences
before returning. Otherwise my ``branch``, ``turn``, and ``tick`` will stay
where they are until that's done.
|
f9021:c35:m26
|
def remove(self, branch, turn, tick):
|
for parent, entitys in list(self.parents.items()):<EOL><INDENT>for entity, keys in list(entitys.items()):<EOL><INDENT>for key, branchs in list(keys.items()):<EOL><INDENT>if branch in branchs:<EOL><INDENT>branhc = branchs[branch]<EOL>if turn in branhc:<EOL><INDENT>trun = branhc[turn]<EOL>if tick in trun:<EOL><INDENT>del trun[tick]<EOL><DEDENT>trun.truncate(tick)<EOL>if not trun:<EOL><INDENT>del branhc[turn]<EOL><DEDENT><DEDENT>branhc.truncate(turn)<EOL>if not branhc:<EOL><INDENT>del branchs[branch]<EOL><DEDENT><DEDENT>if not branchs:<EOL><INDENT>del keys[key]<EOL><DEDENT><DEDENT>if not keys:<EOL><INDENT>del entitys[entity]<EOL><DEDENT><DEDENT>if not entitys:<EOL><INDENT>del self.parents[parent]<EOL><DEDENT><DEDENT>for branchkey, branches in list(self.branches.items()):<EOL><INDENT>if branch in branches:<EOL><INDENT>branhc = branches[branch]<EOL>if turn in branhc:<EOL><INDENT>trun = branhc[turn]<EOL>if tick in trun:<EOL><INDENT>del trun[tick]<EOL><DEDENT>trun.truncate(tick)<EOL>if not trun:<EOL><INDENT>del branhc[turn]<EOL><DEDENT><DEDENT>branhc.truncate(turn)<EOL>if not branhc:<EOL><INDENT>del branches[branch]<EOL><DEDENT><DEDENT>if not branches:<EOL><INDENT>del self.branches[branchkey]<EOL><DEDENT><DEDENT>for keykey, keys in list(self.keys.items()):<EOL><INDENT>for key, branchs in list(keys.items()):<EOL><INDENT>if branch in branchs:<EOL><INDENT>branhc = branchs[branch]<EOL>if turn in branhc:<EOL><INDENT>trun = branhc[turn]<EOL>if tick in trun:<EOL><INDENT>del trun[tick]<EOL><DEDENT>trun.truncate(tick)<EOL>if not trun:<EOL><INDENT>del branhc[turn]<EOL><DEDENT><DEDENT>branhc.truncate(turn)<EOL>if not branhc:<EOL><INDENT>del branches[branch]<EOL><DEDENT><DEDENT>if not branchs:<EOL><INDENT>del keys[key]<EOL><DEDENT><DEDENT>if not keys:<EOL><INDENT>del self.keys[keykey]<EOL><DEDENT><DEDENT>sets = self.settings[branch]<EOL>if turn in sets:<EOL><INDENT>setsturn = sets[turn]<EOL>if tick in setsturn:<EOL><INDENT>del setsturn[tick]<EOL><DEDENT>setsturn.truncate(tick)<EOL>if not setsturn:<EOL><INDENT>del sets[turn]<EOL><DEDENT><DEDENT>sets.truncate(turn)<EOL>if not sets:<EOL><INDENT>del self.settings[branch]<EOL><DEDENT>presets = self.presettings[branch]<EOL>if turn in presets:<EOL><INDENT>presetsturn = presets[turn]<EOL>if tick in presetsturn:<EOL><INDENT>del presetsturn[tick]<EOL><DEDENT>presetsturn.truncate(tick)<EOL>if not presetsturn:<EOL><INDENT>del presets[turn]<EOL><DEDENT><DEDENT>presets.truncate(turn)<EOL>if not presets:<EOL><INDENT>del self.presettings[branch]<EOL><DEDENT>for entity, brnch in list(self.keycache):<EOL><INDENT>if brnch == branch:<EOL><INDENT>kc = self.keycache[entity, brnch]<EOL>if turn in kc:<EOL><INDENT>kcturn = kc[turn]<EOL>if tick in kcturn:<EOL><INDENT>del kcturn[tick]<EOL><DEDENT>kcturn.truncate(tick)<EOL>if not kcturn:<EOL><INDENT>del kc[turn]<EOL><DEDENT><DEDENT>kc.truncate(turn)<EOL>if not kc:<EOL><INDENT>del self.keycache[entity, brnch]<EOL><DEDENT><DEDENT><DEDENT>self.shallowest = OrderedDict()<EOL>self.send(self, branch=branch, turn=turn, tick=tick, action='<STR_LIT>')<EOL>
|
Delete data on or after this tick
On the assumption that the future has been invalidated.
|
f9022:c13:m2
|
def truncate_loc(self, character, location, branch, turn, tick):
|
r = False<EOL>branches_turns = self.branches[character, location][branch]<EOL>branches_turns.truncate(turn)<EOL>if turn in branches_turns:<EOL><INDENT>bttrn = branches_turns[turn]<EOL>if bttrn.future(tick):<EOL><INDENT>bttrn.truncate(tick)<EOL>r = True<EOL><DEDENT><DEDENT>keyses = self.keys[character, location]<EOL>for keysbranches in keyses.values():<EOL><INDENT>if branch not in keysbranches:<EOL><INDENT>continue<EOL><DEDENT>keysbranch = keysbranches[branch]<EOL>if keysbranch.future(turn):<EOL><INDENT>keysbranch.truncate(turn)<EOL>r = True<EOL><DEDENT>if turn in keysbranch:<EOL><INDENT>keysbranchturn = keysbranch[turn]<EOL>if keysbranchturn.future(tick):<EOL><INDENT>keysbranchturn.truncate(tick)<EOL>r = True<EOL><DEDENT><DEDENT><DEDENT>if branch in self.settings:<EOL><INDENT>for sets in (self.settings, self.presettings):<EOL><INDENT>sets_branch = sets[branch]<EOL>if turn in sets_branch:<EOL><INDENT>sets_turn = sets_branch[turn]<EOL>for tic, setting in list(sets_turn.future(tick).items()):<EOL><INDENT>if setting[:<NUM_LIT:2>] == (character, location):<EOL><INDENT>del sets_turn[tic]<EOL>r = True<EOL><DEDENT><DEDENT>if not sets_turn:<EOL><INDENT>del sets_branch[turn]<EOL>assert r, "<STR_LIT>"<EOL><DEDENT><DEDENT>for trn, tics in list(sets_branch.future(turn).items()):<EOL><INDENT>for tic, setting in list(tics.future(tick).items()):<EOL><INDENT>if setting[:<NUM_LIT:2>] == (character, location):<EOL><INDENT>del tics[tic]<EOL>r = True<EOL><DEDENT><DEDENT>if not tics:<EOL><INDENT>del sets_branch[trn]<EOL>assert r, "<STR_LIT>"<EOL><DEDENT><DEDENT>if not sets_branch:<EOL><INDENT>del sets[branch]<EOL>assert r, "<STR_LIT>"<EOL><DEDENT><DEDENT><DEDENT>self.shallowest = OrderedDict()<EOL>return r<EOL>
|
Remove future data about a particular location
Return True if I deleted anything, False otherwise.
|
f9022:c13:m3
|
def roundtrip_dedent(source):
|
return unparse(parse(dedent_source(source)))<EOL>
|
Reformat some lines of code into what unparse makes.
|
f9023:m0
|
def __init__(<EOL>self,<EOL>engine,<EOL>name,<EOL>triggers=None,<EOL>prereqs=None,<EOL>actions=None,<EOL>create=True<EOL>):
|
self.engine = engine<EOL>self.name = self.__name__ = name<EOL>branch, turn, tick = engine._btt()<EOL>if create and not self.engine._triggers_cache.contains_key(name, branch, turn, tick):<EOL><INDENT>tick += <NUM_LIT:1><EOL>self.engine.tick = tick<EOL>triggers = tuple(self._fun_names_iter('<STR_LIT>', triggers or []))<EOL>prereqs = tuple(self._fun_names_iter('<STR_LIT>', prereqs or []))<EOL>actions = tuple(self._fun_names_iter('<STR_LIT:action>', actions or []))<EOL>self.engine.query.set_rule(<EOL>name, branch, turn, tick, triggers, prereqs, actions<EOL>)<EOL>self.engine._triggers_cache.store(name, branch, turn, tick, triggers)<EOL>self.engine._prereqs_cache.store(name, branch, turn, tick, prereqs)<EOL>self.engine._actions_cache.store(name, branch, turn, tick, actions)<EOL><DEDENT>
|
Store the engine and my name, make myself a record in the database
if needed, and instantiate one FunList each for my triggers,
actions, and prereqs.
|
f9023:c5:m0
|
def _fun_names_iter(self, functyp, val):
|
funcstore = getattr(self.engine, functyp)<EOL>for v in val:<EOL><INDENT>if callable(v):<EOL><INDENT>setattr(funcstore, v.__name__, v)<EOL>yield v.__name__<EOL><DEDENT>elif v not in funcstore:<EOL><INDENT>raise KeyError("<STR_LIT>".format(<EOL>v, funcstore._tab<EOL>))<EOL><DEDENT>else:<EOL><INDENT>yield v<EOL><DEDENT><DEDENT>
|
Iterate over the names of the functions in ``val``,
adding them to ``funcstore`` if they are missing;
or if the items in ``val`` are already the names of functions
in ``funcstore``, iterate over those.
|
f9023:c5:m2
|
def trigger(self, fun):
|
self.triggers.append(fun)<EOL>return fun<EOL>
|
Decorator to append the function to my triggers list.
|
f9023:c5:m4
|
def prereq(self, fun):
|
self.prereqs.append(fun)<EOL>return fun<EOL>
|
Decorator to append the function to my prereqs list.
|
f9023:c5:m5
|
def action(self, fun):
|
self.actions.append(fun)<EOL>return fun<EOL>
|
Decorator to append the function to my actions list.
|
f9023:c5:m6
|
def duplicate(self, newname):
|
if self.engine.rule.query.haverule(newname):<EOL><INDENT>raise KeyError("<STR_LIT>".format(newname))<EOL><DEDENT>return Rule(<EOL>self.engine,<EOL>newname,<EOL>list(self.triggers),<EOL>list(self.prereqs),<EOL>list(self.actions)<EOL>)<EOL>
|
Return a new rule that's just like this one, but under a new
name.
|
f9023:c5:m7
|
def always(self):
|
self.triggers = [self.engine.trigger.truth]<EOL>
|
Arrange to be triggered every tick, regardless of circumstance.
|
f9023:c5:m8
|
@abstractmethod<EOL><INDENT>def _get_rule_mapping(self):<DEDENT>
|
raise NotImplementedError<EOL>
|
Get the :class:`RuleMapping` for my rulebook.
|
f9023:c8:m9
|
@abstractmethod<EOL><INDENT>def _get_rulebook_name(self):<DEDENT>
|
raise NotImplementedError<EOL>
|
Get the name of my rulebook.
|
f9023:c8:m10
|
@abstractmethod<EOL><INDENT>def _set_rulebook_name(self, n):<DEDENT>
|
raise NotImplementedError<EOL>
|
Tell the database that this is the name of the rulebook to use for
me.
|
f9023:c8:m11
|
def new_empty(self, name):
|
if name in self:<EOL><INDENT>raise KeyError("<STR_LIT>".format(name))<EOL><DEDENT>new = Rule(self.engine, name)<EOL>self._cache[name] = new<EOL>self.send(self, rule=new, active=True)<EOL>return new<EOL>
|
Make a new rule with no actions or anything, and return it.
|
f9023:c10:m9
|
@contextmanager<EOL><INDENT>def loading(self):<DEDENT>
|
if getattr(self, '<STR_LIT>', False):<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>self._initialized = False<EOL>yield<EOL>self._initialized = True<EOL>
|
Context manager for when you need to instantiate entities upon unpacking
|
f9024:c5:m0
|
def coinflip(self):
|
return self.choice((True, False))<EOL>
|
Return True or False with equal probability.
|
f9024:c5:m31
|
def roll_die(self, d):
|
return self.randint(<NUM_LIT:1>, d)<EOL>
|
Roll a die with ``d`` faces. Return the result.
|
f9024:c5:m32
|
def dice(self, n, d):
|
for i in range(<NUM_LIT:0>, n):<EOL><INDENT>yield self.roll_die(d)<EOL><DEDENT>
|
Roll ``n`` dice with ``d`` faces, and yield the results.
This is an iterator. You'll get the result of each die in
successon.
|
f9024:c5:m33
|
def dice_check(self, n, d, target, comparator='<STR_LIT>'):
|
from operator import gt, lt, ge, le, eq, ne<EOL>comps = {<EOL>'<STR_LIT:>>': gt,<EOL>'<STR_LIT:<>': lt,<EOL>'<STR_LIT>': ge,<EOL>'<STR_LIT>': le,<EOL>'<STR_LIT:=>': eq,<EOL>'<STR_LIT>': eq,<EOL>'<STR_LIT>': ne<EOL>}<EOL>try:<EOL><INDENT>comparator = comps.get(comparator, comparator)<EOL><DEDENT>except TypeError:<EOL><INDENT>pass<EOL><DEDENT>return comparator(sum(self.dice(n, d)), target)<EOL>
|
Roll ``n`` dice with ``d`` sides, sum them, and return whether they
are <= ``target``.
If ``comparator`` is provided, use it instead of <=. You may
use a string like '<' or '>='.
|
f9024:c5:m34
|
def percent_chance(self, pct):
|
if pct <= <NUM_LIT:0>:<EOL><INDENT>return False<EOL><DEDENT>if pct >= <NUM_LIT:100>:<EOL><INDENT>return True<EOL><DEDENT>return pct / <NUM_LIT:100> < self.random()<EOL>
|
Given a ``pct``% chance of something happening right now, decide at
random whether it actually happens, and return ``True`` or
``False`` as appropriate.
Values not between 0 and 100 are treated as though they
were 0 or 100, whichever is nearer.
|
f9024:c5:m35
|
def get_delta(self, branch, turn_from, tick_from, turn_to, tick_to):
|
from allegedb.window import update_window, update_backward_window<EOL>if turn_from == turn_to:<EOL><INDENT>return self.get_turn_delta(branch, turn_to, tick_to, start_tick=tick_from)<EOL><DEDENT>delta = super().get_delta(branch, turn_from, tick_from, turn_to, tick_to)<EOL>if turn_from < turn_to:<EOL><INDENT>updater = partial(update_window, turn_from, tick_from, turn_to, tick_to)<EOL>univbranches = self._universal_cache.settings<EOL>avbranches = self._avatarness_cache.settings<EOL>thbranches = self._things_cache.settings<EOL>rbbranches = self._rulebooks_cache.settings<EOL>trigbranches = self._triggers_cache.settings<EOL>preqbranches = self._prereqs_cache.settings<EOL>actbranches = self._actions_cache.settings<EOL>charrbbranches = self._characters_rulebooks_cache.settings<EOL>avrbbranches = self._avatars_rulebooks_cache.settings<EOL>charthrbbranches = self._characters_things_rulebooks_cache.settings<EOL>charplrbbranches = self._characters_places_rulebooks_cache.settings<EOL>charporbbranches = self._characters_portals_rulebooks_cache.settings<EOL>noderbbranches = self._nodes_rulebooks_cache.settings<EOL>edgerbbranches = self._portals_rulebooks_cache.settings<EOL><DEDENT>else:<EOL><INDENT>updater = partial(update_backward_window, turn_from, tick_from, turn_to, tick_to)<EOL>univbranches = self._universal_cache.presettings<EOL>avbranches = self._avatarness_cache.presettings<EOL>thbranches = self._things_cache.presettings<EOL>rbbranches = self._rulebooks_cache.presettings<EOL>trigbranches = self._triggers_cache.presettings<EOL>preqbranches = self._prereqs_cache.presettings<EOL>actbranches = self._actions_cache.presettings<EOL>charrbbranches = self._characters_rulebooks_cache.presettings<EOL>avrbbranches = self._avatars_rulebooks_cache.presettings<EOL>charthrbbranches = self._characters_things_rulebooks_cache.presettings<EOL>charplrbbranches = self._characters_places_rulebooks_cache.presettings<EOL>charporbbranches = self._characters_portals_rulebooks_cache.presettings<EOL>noderbbranches = self._nodes_rulebooks_cache.presettings<EOL>edgerbbranches = self._portals_rulebooks_cache.presettings<EOL><DEDENT>def upduniv(_, key, val):<EOL><INDENT>delta.setdefault('<STR_LIT>', {})[key] = val<EOL><DEDENT>if branch in univbranches:<EOL><INDENT>updater(upduniv, univbranches[branch])<EOL><DEDENT>def updav(char, graph, node, av):<EOL><INDENT>delta.setdefault(char, {}).setdefault('<STR_LIT>', {}).setdefault(graph, {})[node] = bool(av)<EOL><DEDENT>if branch in avbranches:<EOL><INDENT>updater(updav, avbranches[branch])<EOL><DEDENT>def updthing(char, thing, loc):<EOL><INDENT>if (<EOL>char in delta and '<STR_LIT>' in delta[char]<EOL>and thing in delta[char]['<STR_LIT>'] and not<EOL>delta[char]['<STR_LIT>'][thing]<EOL>):<EOL><INDENT>return<EOL><DEDENT>thingd = delta.setdefault(char, {}).setdefault('<STR_LIT>', {}).setdefault(thing, {})<EOL>thingd['<STR_LIT:location>'] = loc<EOL><DEDENT>if branch in thbranches:<EOL><INDENT>updater(updthing, thbranches[branch])<EOL><DEDENT>def updrb(whatev, rulebook, rules):<EOL><INDENT>delta.setdefault('<STR_LIT>', {})[rulebook] = rules<EOL><DEDENT>if branch in rbbranches:<EOL><INDENT>updater(updrb, rbbranches[branch])<EOL><DEDENT>def updru(key, _, rule, funs):<EOL><INDENT>delta.setdefault('<STR_LIT>', {}).setdefault(rule, {})[key] = funs<EOL><DEDENT>if branch in trigbranches:<EOL><INDENT>updater(partial(updru, '<STR_LIT>'), trigbranches[branch])<EOL><DEDENT>if branch in preqbranches:<EOL><INDENT>updater(partial(updru, '<STR_LIT>'), preqbranches[branch])<EOL><DEDENT>if branch in actbranches:<EOL><INDENT>updater(partial(updru, '<STR_LIT>'), actbranches[branch])<EOL><DEDENT>def updcrb(key, _, character, rulebook):<EOL><INDENT>delta.setdefault(character, {})[key] = rulebook<EOL><DEDENT>if branch in charrbbranches:<EOL><INDENT>updater(partial(updcrb, '<STR_LIT>'), charrbbranches[branch])<EOL><DEDENT>if branch in avrbbranches:<EOL><INDENT>updater(partial(updcrb, '<STR_LIT>'), avrbbranches[branch])<EOL><DEDENT>if branch in charthrbbranches:<EOL><INDENT>updater(partial(updcrb, '<STR_LIT>'), charthrbbranches[branch])<EOL><DEDENT>if branch in charplrbbranches:<EOL><INDENT>updater(partial(updcrb, '<STR_LIT>'), charplrbbranches[branch])<EOL><DEDENT>if branch in charporbbranches:<EOL><INDENT>updater(partial(updcrb, '<STR_LIT>'), charporbbranches[branch])<EOL><DEDENT>def updnoderb(character, node, rulebook):<EOL><INDENT>if (<EOL>character in delta and '<STR_LIT>' in delta[character]<EOL>and node in delta[character]['<STR_LIT>'] and not delta[character]['<STR_LIT>'][node]<EOL>):<EOL><INDENT>return<EOL><DEDENT>delta.setdefault(character, {}).setdefault('<STR_LIT>', {}).setdefault(node, {})['<STR_LIT>'] = rulebook<EOL><DEDENT>if branch in noderbbranches:<EOL><INDENT>updater(updnoderb, noderbbranches[branch])<EOL><DEDENT>def updedgerb(character, orig, dest, rulebook):<EOL><INDENT>if (<EOL>character in delta and '<STR_LIT>' in delta[character]<EOL>and orig in delta[character]['<STR_LIT>'] and dest in delta[character]['<STR_LIT>'][orig]<EOL>and not delta[character]['<STR_LIT>'][orig][dest]<EOL>):<EOL><INDENT>return<EOL><DEDENT>delta.setdefault(character, {}).setdefault('<STR_LIT>', {}).setdefault(<EOL>orig, {}).setdefault(dest, {})['<STR_LIT>'] = rulebook<EOL><DEDENT>if branch in edgerbbranches:<EOL><INDENT>updater(updedgerb, edgerbbranches[branch])<EOL><DEDENT>return delta<EOL>
|
Get a dictionary describing changes to the world.
Most keys will be character names, and their values will be dictionaries of
the character's stats' new values, with ``None`` for deleted keys. Characters'
dictionaries have special keys 'nodes' and 'edges' which contain booleans indicating
whether the node or edge exists at the moment, and 'node_val' and 'edge_val' for
the stats of those entities. For edges (also called portals) these dictionaries
are two layers deep, keyed first by the origin, then by the destination.
Characters also have special keys for the various rulebooks they have:
* 'character_rulebook'
* 'avatar_rulebook'
* 'character_thing_rulebook'
* 'character_place_rulebook'
* 'character_portal_rulebook'
And each node and edge may have a 'rulebook' stat of its own. If a node is a thing,
it gets a 'location'; when the 'location' is deleted,
that means it's back to being a place.
Keys at the top level that are not character names:
* 'rulebooks', a dictionary keyed by the name of each changed rulebook, the value
being a list of rule names
* 'rules', a dictionary keyed by the name of each changed rule, containing any
of the lists 'triggers', 'prereqs', and 'actions'
|
f9024:c6:m2
|
def get_turn_delta(self, branch=None, turn=None, tick=None, start_tick=<NUM_LIT:0>):
|
branch = branch or self.branch<EOL>turn = turn or self.turn<EOL>tick = tick or self.tick<EOL>delta = super().get_turn_delta(branch, turn, start_tick, tick)<EOL>if branch in self._avatarness_cache.settings and turn in self._avatarness_cache.settings[branch]:<EOL><INDENT>for chara, graph, node, is_av in self._avatarness_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>delta.setdefault(chara, {}).setdefault('<STR_LIT>', {}).setdefault(graph, {})[node] = is_av<EOL><DEDENT><DEDENT>if branch in self._things_cache.settings and turn in self._things_cache.settings[branch]:<EOL><INDENT>for chara, thing, location in self._things_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>thingd = delta.setdefault(chara, {}).setdefault('<STR_LIT>', {}).setdefault(thing, {})<EOL>thingd['<STR_LIT:location>'] = location<EOL><DEDENT><DEDENT>delta['<STR_LIT>'] = rbdif = {}<EOL>if branch in self._rulebooks_cache.settings and turn in self._rulebooks_cache.settings[branch]:<EOL><INDENT>for _, rulebook, rules in self._rulebooks_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>rbdif[rulebook] = rules<EOL><DEDENT><DEDENT>delta['<STR_LIT>'] = rdif = {}<EOL>if branch in self._triggers_cache.settings and turn in self._triggers_cache.settings[branch]:<EOL><INDENT>for _, rule, funs in self._triggers_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>rdif.setdefault(rule, {})['<STR_LIT>'] = funs<EOL><DEDENT><DEDENT>if branch in self._prereqs_cache.settings and turn in self._prereqs_cache.settings[branch]:<EOL><INDENT>for _, rule, funs in self._prereqs_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>rdif.setdefault(rule, {})['<STR_LIT>'] = funs<EOL><DEDENT><DEDENT>if branch in self._actions_cache.settings and turn in self._triggers_cache.settings[branch]:<EOL><INDENT>for _, rule, funs in self._triggers_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>rdif.setdefault(rule, {})['<STR_LIT>'] = funs<EOL><DEDENT><DEDENT>if branch in self._characters_rulebooks_cache.settings and turn in self._characters_rulebooks_cache.settings[branch]:<EOL><INDENT>for _, character, rulebook in self._characters_rulebooks_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>delta.setdefault(character, {})['<STR_LIT>'] = rulebook<EOL><DEDENT><DEDENT>if branch in self._avatars_rulebooks_cache.settings and turn in self._avatars_rulebooks_cache.settings[branch]:<EOL><INDENT>for _, character, rulebook in self._avatars_rulebooks_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>delta.setdefault(character, {})['<STR_LIT>'] = rulebook<EOL><DEDENT><DEDENT>if branch in self._characters_things_rulebooks_cache.settings and turn in self._characters_things_rulebooks_cache.settings[branch]:<EOL><INDENT>for _, character, rulebook in self._characters_things_rulebooks_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>delta.setdefault(character, {})['<STR_LIT>'] = rulebook<EOL><DEDENT><DEDENT>if branch in self._characters_places_rulebooks_cache.settings and turn in self._characters_places_rulebooks_cache.settings[branch]:<EOL><INDENT>for _, character, rulebook in self._characters_places_rulebooks_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>delta.setdefault(character, {})['<STR_LIT>'] = rulebook<EOL><DEDENT><DEDENT>if branch in self._characters_portals_rulebooks_cache.settings and turn in self._characters_portals_rulebooks_cache.settings[branch]:<EOL><INDENT>for _, character, rulebook in self._characters_portals_rulebooks_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>delta.setdefault(character, {})['<STR_LIT>'] = rulebook<EOL><DEDENT><DEDENT>if branch in self._nodes_rulebooks_cache.settings and turn in self._nodes_rulebooks_cache.settings[branch]:<EOL><INDENT>for character, node, rulebook in self._nodes_rulebooks_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>delta.setdefault(character, {}).setdefault('<STR_LIT>', {}).setdefault(node, {})['<STR_LIT>'] = rulebook<EOL><DEDENT><DEDENT>if branch in self._portals_rulebooks_cache.settings and turn in self._portals_rulebooks_cache.settings[branch]:<EOL><INDENT>for character, orig, dest, rulebook in self._portals_rulebooks_cache.settings[branch][turn][start_tick:tick]:<EOL><INDENT>delta.setdefault(character, {}).setdefault('<STR_LIT>', {}).setdefault(orig, {}).setdefault(dest, {})['<STR_LIT>'] = rulebook<EOL><DEDENT><DEDENT>return delta<EOL>
|
Get a dictionary describing changes to the world within a given turn
Defaults to the present turn, and stops at the present tick unless specified.
See the documentation for ``get_delta`` for a detailed description of the
delta format.
:arg branch: branch of history, defaulting to the present branch
:arg turn: turn within the branch, defaulting to the present turn
:arg tick: tick at which to stop the delta, defaulting to the present tick
:arg start_tick: tick at which to start the delta, defaulting to 0
|
f9024:c6:m3
|
def _remember_avatarness(<EOL>self, character, graph, node,<EOL>is_avatar=True, branch=None, turn=None,<EOL>tick=None<EOL>):
|
branch = branch or self.branch<EOL>turn = turn or self.turn<EOL>tick = tick or self.tick<EOL>self._avatarness_cache.store(<EOL>character,<EOL>graph,<EOL>node,<EOL>branch,<EOL>turn,<EOL>tick,<EOL>is_avatar<EOL>)<EOL>self.query.avatar_set(<EOL>character,<EOL>graph,<EOL>node,<EOL>branch,<EOL>turn,<EOL>tick,<EOL>is_avatar<EOL>)<EOL>
|
Use this to record a change in avatarness.
Should be called whenever a node that wasn't an avatar of a
character now is, and whenever a node that was an avatar of a
character now isn't.
``character`` is the one using the node as an avatar,
``graph`` is the character the node is in.
|
f9024:c6:m5
|
def __init__(<EOL>self,<EOL>worlddb,<EOL>*,<EOL>string='<STR_LIT>',<EOL>function='<STR_LIT>',<EOL>method='<STR_LIT>',<EOL>trigger='<STR_LIT>',<EOL>prereq='<STR_LIT>',<EOL>action='<STR_LIT>',<EOL>connect_args={},<EOL>alchemy=False,<EOL>commit_modulus=None,<EOL>random_seed=None,<EOL>logfun=None,<EOL>validate=False,<EOL>clear=False,<EOL>):
|
import os<EOL>worlddbpath = worlddb.replace('<STR_LIT>', '<STR_LIT>')<EOL>if clear and os.path.exists(worlddbpath):<EOL><INDENT>os.remove(worlddbpath)<EOL><DEDENT>if isinstance(string, str):<EOL><INDENT>self._string_file = string<EOL>if clear and os.path.exists(string):<EOL><INDENT>os.remove(string)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.string = string<EOL><DEDENT>if isinstance(function, str):<EOL><INDENT>self._function_file = function<EOL>if clear and os.path.exists(function):<EOL><INDENT>os.remove(function)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.function = function<EOL><DEDENT>if isinstance(method, str):<EOL><INDENT>self._method_file = method<EOL>if clear and os.path.exists(method):<EOL><INDENT>os.remove(method)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.method = method<EOL><DEDENT>if isinstance(trigger, str):<EOL><INDENT>self._trigger_file = trigger<EOL>if clear and os.path.exists(trigger):<EOL><INDENT>os.remove(trigger)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.trigger = trigger<EOL><DEDENT>if isinstance(prereq, str):<EOL><INDENT>self._prereq_file = prereq<EOL>if clear and os.path.exists(prereq):<EOL><INDENT>os.remove(prereq)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.prereq = prereq<EOL><DEDENT>if isinstance(action, str):<EOL><INDENT>self._action_file = action<EOL>if clear and os.path.exists(action):<EOL><INDENT>os.remove(action)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.action = action<EOL><DEDENT>super().__init__(<EOL>worlddb,<EOL>connect_args=connect_args,<EOL>alchemy=alchemy,<EOL>validate=validate<EOL>)<EOL>self.next_turn = NextTurn(self)<EOL>if logfun is None:<EOL><INDENT>from logging import getLogger<EOL>logger = getLogger(__name__)<EOL>def logfun(level, msg):<EOL><INDENT>getattr(logger, level)(msg)<EOL><DEDENT><DEDENT>self.log = logfun<EOL>self.commit_modulus = commit_modulus<EOL>self.random_seed = random_seed<EOL>self._rules_iter = self._follow_rules()<EOL>from random import Random<EOL>self._rando = Random()<EOL>if '<STR_LIT>' in self.universal:<EOL><INDENT>self._rando.setstate(self.universal['<STR_LIT>'])<EOL><DEDENT>else:<EOL><INDENT>self._rando.seed(self.random_seed)<EOL>self.universal['<STR_LIT>'] = self._rando.getstate()<EOL><DEDENT>if hasattr(self.method, '<STR_LIT>'):<EOL><INDENT>self.method.init(self)<EOL><DEDENT>
|
Store the connections for the world database and the code database;
set up listeners; and start a transaction
:arg worlddb: Either a path to a SQLite database, or a rfc1738 URI for a database to connect to.
:arg string: path to a JSON file storing strings to be used in the game
:arg function: either a Python module or a path to a source file; should contain utility functions
:arg method: either a Python module or a path to a source file; should contain functions taking this engine as first arg
:arg trigger: either a Python module or a path to a source file; should contain trigger functions, taking a LiSE entity and returning a boolean for whether to run a rule
:arg prereq: either a Python module or a path to a source file; should contain prereq functions, taking a LiSE entity and returning a boolean for whether to permit a rule to run
:arg action: either a Python module or a path to a source file; should contain action functions, taking a LiSE entity and mutating it (and possibly the rest of the world)
:arg connect_args: dictionary of keyword arguments for the database connection
:arg alchemy: whether to use SQLAlchemy to connect to the database. If False, LiSE can only use SQLite
:arg commit_modulus: LiSE will commit changes to disk every ``commit_modulus`` turns
:arg random_seed: a number to initialize the randomizer
:arg logfun: an optional function taking arguments ``level, message`` and
:arg validate: whether to perform integrity tests while loading the game
:arg clear: whether to delete *any and all* existing data and code. Use with caution!
|
f9024:c6:m8
|
def debug(self, msg):
|
self.log('<STR_LIT>', msg)<EOL>
|
Log a message at level 'debug
|
f9024:c6:m11
|
def info(self, msg):
|
self.log('<STR_LIT:info>', msg)<EOL>
|
Log a message at level 'info
|
f9024:c6:m12
|
def warning(self, msg):
|
self.log('<STR_LIT>', msg)<EOL>
|
Log a message at level 'warning
|
f9024:c6:m13
|
def error(self, msg):
|
self.log('<STR_LIT:error>', msg)<EOL>
|
Log a message at level 'error
|
f9024:c6:m14
|
def critical(self, msg):
|
self.log('<STR_LIT>', msg)<EOL>
|
Log a message at level 'critical
|
f9024:c6:m15
|
def close(self):
|
import sys, os<EOL>for store in self.stores:<EOL><INDENT>if hasattr(store, '<STR_LIT>'):<EOL><INDENT>store.save(reimport=False)<EOL><DEDENT>path, filename = os.path.split(store._filename)<EOL>modname = filename[:-<NUM_LIT:3>]<EOL>if modname in sys.modules:<EOL><INDENT>del sys.modules[modname]<EOL><DEDENT><DEDENT>super().close()<EOL>
|
Commit changes and close the database.
|
f9024:c6:m17
|
def __enter__(self):
|
return self<EOL>
|
Return myself. For compatibility with ``with`` semantics.
|
f9024:c6:m18
|
def __exit__(self, *args):
|
self.close()<EOL>
|
Close on exit.
|
f9024:c6:m19
|
def advance(self):
|
try:<EOL><INDENT>return next(self._rules_iter)<EOL><DEDENT>except InnerStopIteration:<EOL><INDENT>self._rules_iter = self._follow_rules()<EOL>return StopIteration()<EOL><DEDENT>except StopIteration:<EOL><INDENT>self._rules_iter = self._follow_rules()<EOL>return final_rule<EOL><DEDENT>
|
Follow the next rule if available.
If we've run out of rules, reset the rules iterator.
|
f9024:c6:m32
|
def new_character(self, name, data=None, **kwargs):
|
self.add_character(name, data, **kwargs)<EOL>return self.character[name]<EOL>
|
Create and return a new :class:`Character`.
|
f9024:c6:m33
|
def add_character(self, name, data=None, **kwargs):
|
self._init_graph(name, '<STR_LIT>')<EOL>self._graph_objs[name] = self.char_cls(self, name, data, **kwargs)<EOL>
|
Create a new character.
You'll be able to access it as a :class:`Character` object by
looking up ``name`` in my ``character`` property.
``data``, if provided, should be a networkx-compatible graph
object. Your new character will be a copy of it.
Any keyword arguments will be set as stats of the new character.
|
f9024:c6:m34
|
def del_character(self, name):
|
self.query.del_character(name)<EOL>self.del_graph(name)<EOL>del self.character[name]<EOL>
|
Remove the Character from the database entirely.
This also deletes all its history. You'd better be sure.
|
f9024:c6:m35
|
def alias(self, v, stat='<STR_LIT>'):
|
from .util import EntityStatAccessor<EOL>r = DummyEntity(self)<EOL>r[stat] = v<EOL>return EntityStatAccessor(r, stat, engine=self)<EOL>
|
Return a representation of a value suitable for use in historical queries.
It will behave much as if you assigned the value to some entity and then used its
``historical`` method to get a reference to the set of its past values, which
happens to contain only the value you've provided here, ``v``.
:arg v: the value to represent
:arg stat: what name to pretend its stat has; usually irrelevant
|
f9024:c6:m38
|
def turns_when(self, qry):
|
<EOL>for branch, turn in qry.iter_turns():<EOL><INDENT>yield turn<EOL><DEDENT>
|
Iterate over the turns in this branch when the query held true
:arg qry: a Query, likely constructed by comparing the result of a call to an entity's
``historical`` method with the output of ``self.alias(..)`` or another ``historical(..)``
|
f9024:c6:m40
|
def roommate_collisions(engine):
|
done = set()<EOL>for chara in engine.character.values():<EOL><INDENT>if chara.name in done:<EOL><INDENT>continue<EOL><DEDENT>match = re.match('<STR_LIT>', chara.name)<EOL>if not match:<EOL><INDENT>continue<EOL><DEDENT>dorm, room, student = match.groups()<EOL>other_student = '<STR_LIT:1>' if student == '<STR_LIT:0>' else '<STR_LIT:0>'<EOL>student = chara<EOL>other_student = engine.character[<EOL>'<STR_LIT>'.format(dorm, room, other_student)<EOL>]<EOL>same_loc_turns = list(engine.turns_when(<EOL>student.avatar.only.historical('<STR_LIT:location>')<EOL>== other_student.avatar.only.historical('<STR_LIT:location>')<EOL>))<EOL>assert same_loc_turns, "<STR_LIT>".format(<EOL>student.name, other_student.name<EOL>)<EOL>assert len(same_loc_turns) >= <NUM_LIT:6>, "<STR_LIT>".format(<EOL>student.name, other_student.name<EOL>)<EOL>done.add(student.name)<EOL>done.add(other_student.name)<EOL><DEDENT>
|
Test queries' ability to tell that all of the students that share
rooms have been in the same place.
|
f9027:m1
|
def sober_collisions(engine):
|
students = [<EOL>stu for stu in<EOL>engine.character['<STR_LIT>'].stat['<STR_LIT>']<EOL>if not (stu.stat['<STR_LIT>'] or stu.stat['<STR_LIT>'])<EOL>]<EOL>assert students<EOL>def sameClasstime(stu0, stu1):<EOL><INDENT>assert list(<EOL>engine.turns_when(<EOL>stu0.avatar.only.historical('<STR_LIT:location>') ==<EOL>stu1.avatar.only.historical('<STR_LIT:location>') ==<EOL>engine.alias('<STR_LIT>')<EOL>)), """<STR_LIT>""".format(<EOL>stu0=stu0.name,<EOL>stu1=stu1.name,<EOL>turns0=list(engine.turns_when(stu0.avatar.only.historical('<STR_LIT:location>') == engine.alias('<STR_LIT>'))),<EOL>turns1=list(engine.turns_when(stu1.avatar.only.historical('<STR_LIT:location>') == engine.alias('<STR_LIT>')))<EOL>)<EOL>return stu1<EOL><DEDENT>reduce(sameClasstime, students)<EOL>
|
Students that are neither lazy nor drunkards should all have been
in class together at least once.
|
f9027:m3
|
def noncollision(engine):
|
dorm = defaultdict(lambda: defaultdict(dict))<EOL>for character in engine.character.values():<EOL><INDENT>match = re.match('<STR_LIT>', character.name)<EOL>if not match:<EOL><INDENT>continue<EOL><DEDENT>d, r, s = match.groups()<EOL>dorm[d][r][s] = character<EOL><DEDENT>for d in dorm:<EOL><INDENT>other_dorms = [dd for dd in dorm if dd != d]<EOL>for r in dorm[d]:<EOL><INDENT>other_rooms = [rr for rr in dorm[d] if rr != r]<EOL>for stu0 in dorm[d][r].values():<EOL><INDENT>for rr in other_rooms:<EOL><INDENT>for stu1 in dorm[d][rr].values():<EOL><INDENT>assert not list(engine.turns_when(<EOL>stu0.avatar.only.historical('<STR_LIT:location>') ==<EOL>stu1.avatar.only.historical('<STR_LIT:location>') ==<EOL>engine.alias('<STR_LIT>'.format(d, r))<EOL>)), "<STR_LIT>".format(<EOL>stu0.name, stu1.name<EOL>)<EOL><DEDENT><DEDENT>common = '<STR_LIT>'.format(d)<EOL>for dd in other_dorms:<EOL><INDENT>for rr in dorm[dd]:<EOL><INDENT>for stu1 in dorm[dd][rr].values():<EOL><INDENT>assert not list(engine.turns_when(<EOL>stu0.avatar.only.historical('<STR_LIT:location>') ==<EOL>stu1.avatar.only.historical('<STR_LIT:location>') ==<EOL>engine.alias(common)<EOL>)), "<STR_LIT>".format(<EOL>stu0.name, stu1.name<EOL>)<EOL><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT><DEDENT>
|
Make sure students *not* from the same room never go there together
|
f9027:m5
|
def set_in_mapping(mapp, stat, v):
|
<EOL>if stat == '<STR_LIT:name>':<EOL><INDENT>return<EOL><DEDENT>if v is None:<EOL><INDENT>del mapp[stat]<EOL>return<EOL><DEDENT>if stat not in mapp:<EOL><INDENT>mapp[stat] = v<EOL>return<EOL><DEDENT>if isinstance(v, dict) or isinstance(v, set):<EOL><INDENT>mapp[stat].update(v)<EOL>for item in list(mapp[stat]):<EOL><INDENT>if item not in v:<EOL><INDENT>try:<EOL><INDENT>del mapp[stat][item]<EOL><DEDENT>except TypeError:<EOL><INDENT>mapp[stat].remove(item)<EOL><DEDENT><DEDENT><DEDENT><DEDENT>elif isinstance(v, list):<EOL><INDENT>for item in list(mapp[stat]):<EOL><INDENT>if item not in v:<EOL><INDENT>mapp[stat].remove(item)<EOL><DEDENT><DEDENT>for i, item in enumerate(v):<EOL><INDENT>if mapp[stat][i] != item:<EOL><INDENT>mapp[stat].insert(i, item)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>mapp[stat] = v<EOL><DEDENT>
|
Sync a value in ``mapp``, having key ``stat``, with ``v``.
|
f9030:m0
|
def update_char(char, *, stat=(), node=(), portal=()):
|
def update(d, dd):<EOL><INDENT>for k, v in dd.items():<EOL><INDENT>if v is None and k in d:<EOL><INDENT>del d[k]<EOL><DEDENT>else:<EOL><INDENT>d[k] = v<EOL><DEDENT><DEDENT><DEDENT>end_stats = char.stat.unwrap()<EOL>for stat, v in stat:<EOL><INDENT>set_in_mapping(char.stat, stat, v)<EOL>if v is None and stat in end_stats:<EOL><INDENT>del end_stats[stat]<EOL><DEDENT>else:<EOL><INDENT>end_stats[stat] = v<EOL><DEDENT><DEDENT>end_places = char.place.unwrap()<EOL>end_things = char.thing.unwrap()<EOL>for node, v in node:<EOL><INDENT>if '<STR_LIT:name>' not in v:<EOL><INDENT>v['<STR_LIT:name>'] = node<EOL><DEDENT>if v is None:<EOL><INDENT>del char.node[node]<EOL>if node in end_places:<EOL><INDENT>del end_places[node]<EOL><DEDENT>if node in end_things:<EOL><INDENT>del end_things[node]<EOL><DEDENT><DEDENT>elif node in char.place:<EOL><INDENT>if '<STR_LIT:location>' in v:<EOL><INDENT>del end_places[node]<EOL>char.place2thing(node, v.pop('<STR_LIT:location>'))<EOL>if node in end_places:<EOL><INDENT>me = end_things[node] = end_places.pop(node)<EOL><DEDENT>else:<EOL><INDENT>me = end_things[node] = dict(char.thing[node])<EOL><DEDENT>update(me, v)<EOL>for k, vv in v.items():<EOL><INDENT>set_in_mapping(char.thing[node], k, vv)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>if node in end_places:<EOL><INDENT>me = end_places[node]<EOL><DEDENT>else:<EOL><INDENT>me = end_places[node] = dict(char.place[node])<EOL><DEDENT>update(me, v)<EOL>for k, vv in v.items():<EOL><INDENT>set_in_mapping(char.place[node], k, vv)<EOL><DEDENT><DEDENT><DEDENT>elif node in char.thing:<EOL><INDENT>if '<STR_LIT:location>' in v and v['<STR_LIT:location>'] is None:<EOL><INDENT>if node in end_things:<EOL><INDENT>me = end_places[node] = end_things.pop(node)<EOL><DEDENT>else:<EOL><INDENT>me = end_places[node] = dict(char.thing[node])<EOL><DEDENT>del me['<STR_LIT:location>']<EOL>del v['<STR_LIT:location>']<EOL>char.thing2place(node)<EOL>update(me, v)<EOL>for k, vv in v.items():<EOL><INDENT>set_in_mapping(char.place[node], k, vv)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>me = end_things[node] = dict(char.thing[node])<EOL>update(me, v)<EOL>for k, vv in v.items():<EOL><INDENT>set_in_mapping(char.thing[node], k, vv)<EOL><DEDENT><DEDENT><DEDENT>elif '<STR_LIT:location>' in v:<EOL><INDENT>end_things[node] = v<EOL>me = char.new_thing(node, v.pop('<STR_LIT:location>'))<EOL>for k, vv in v.items():<EOL><INDENT>set_in_mapping(me, k, vv)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>end_places[node] = v<EOL>me = char.new_node(node)<EOL>for k, vv in v.items():<EOL><INDENT>set_in_mapping(me, k, vv)<EOL><DEDENT><DEDENT><DEDENT>end_edges = char.portal.unwrap()<EOL>for o, d, v in portal:<EOL><INDENT>if v is None:<EOL><INDENT>del char.edge[o][d]<EOL>del end_edges[o][d]<EOL><DEDENT>else:<EOL><INDENT>me = end_edges.setdefault(o, {}).setdefault(d, {})<EOL>update(me, v)<EOL>e = char.new_portal(o, d)<EOL>for k, vv in v.items():<EOL><INDENT>set_in_mapping(e, k, vv)<EOL><DEDENT><DEDENT><DEDENT>return {<EOL>'<STR_LIT>': end_stats,<EOL>'<STR_LIT>': end_places,<EOL>'<STR_LIT>': end_things,<EOL>'<STR_LIT>': end_edges<EOL>}<EOL>
|
Make a bunch of changes to a character-like object
|
f9030:m1
|
def __init__(<EOL>self,<EOL>message,<EOL>path=None,<EOL>followed=None,<EOL>traveller=None,<EOL>branch=None,<EOL>turn=None,<EOL>lastplace=None<EOL>):
|
self.path = path<EOL>self.followed = followed<EOL>self.traveller = traveller<EOL>self.branch = branch<EOL>self.turn = turn<EOL>self.lastplace = lastplace<EOL>super().__init__(message)<EOL>
|
Store the message as usual, and also the optional arguments:
``path``: a list of Place names to show such a path as you found
``followed``: the portion of the path actually followed
``traveller``: the Thing doing the travelling
``branch``: branch during travel
``tick``: tick at time of error (might not be the tick at the
time this exception is raised)
``lastplace``: where the traveller was, when the error happened
|
f9036:c6:m0
|
def do(self, func, *args, **kwargs):
|
if not callable(func):<EOL><INDENT>func = getattr(self.engine.function, func)<EOL><DEDENT>func(self, *args, **kwargs)<EOL>return self<EOL>
|
Apply the function to myself, and return myself.
Look up the function in the database if needed. Pass it any
arguments given, keyword or positional.
Useful chiefly when chaining.
|
f9037:c1:m28
|
def perlin(self, stat='<STR_LIT>'):
|
from math import floor<EOL>p = self.engine.shuffle([<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:15>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:7>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:30>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:8>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:10>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT:6>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:0>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT:11>, <NUM_LIT:32>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:20>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:1>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:200>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:100>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:3>, <NUM_LIT:64>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:5>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:255>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:16>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:2>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT:9>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT:12>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT:50>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT:4>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>,<EOL><NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT>, <NUM_LIT><EOL>]) * <NUM_LIT:2><EOL>def fade(t):<EOL><INDENT>return t * t * t * (t * (t * <NUM_LIT:6> - <NUM_LIT:15>) + <NUM_LIT:10>)<EOL><DEDENT>def lerp(t, a, b):<EOL><INDENT>return a + t * (b - a)<EOL><DEDENT>def grad(hsh, x, y, z):<EOL><INDENT>"""<STR_LIT>"""<EOL>h = hsh & <NUM_LIT:15><EOL>u = x if h < <NUM_LIT:8> else y<EOL>v = y if h < <NUM_LIT:4> else x if h == <NUM_LIT:12> or h == <NUM_LIT> else z<EOL>return (u if h & <NUM_LIT:1> == <NUM_LIT:0> else -u) + (v if h & <NUM_LIT:2> == <NUM_LIT:0> else -v)<EOL><DEDENT>def noise(x, y, z):<EOL><INDENT>X = int(x) & <NUM_LIT:255><EOL>Y = int(y) & <NUM_LIT:255><EOL>Z = int(z) & <NUM_LIT:255><EOL>x -= floor(x)<EOL>y -= floor(y)<EOL>z -= floor(z)<EOL>u = fade(x)<EOL>v = fade(y)<EOL>w = fade(z)<EOL>A = p[X] + Y<EOL>AA = p[A] + Z<EOL>AB = p[A+<NUM_LIT:1>] + Z<EOL>B = p[X+<NUM_LIT:1>] + y<EOL>BA = p[B] + Z<EOL>BB = p[B+<NUM_LIT:1>] + Z<EOL>return lerp(<EOL>w,<EOL>lerp(<EOL>v,<EOL>lerp(<EOL>u,<EOL>grad(p[AA], x, y, z),<EOL>grad(p[BA], x-<NUM_LIT:1>, y, z)<EOL>),<EOL>lerp(<EOL>u,<EOL>grad(p[AB], x, y-<NUM_LIT:1>, z),<EOL>grad(p[BB], x-<NUM_LIT:1>, y-<NUM_LIT:1>, z)<EOL>)<EOL>),<EOL>lerp(<EOL>v,<EOL>lerp(<EOL>u,<EOL>grad(p[AA+<NUM_LIT:1>], x, y, z-<NUM_LIT:1>),<EOL>grad(p[BA+<NUM_LIT:1>], x-<NUM_LIT:1>, y, z-<NUM_LIT:1>)<EOL>),<EOL>lerp(<EOL>u,<EOL>grad(p[AB+<NUM_LIT:1>], x, y-<NUM_LIT:1>, z-<NUM_LIT:1>),<EOL>grad(p[BB+<NUM_LIT:1>], x-<NUM_LIT:1>, y-<NUM_LIT:1>, z-<NUM_LIT:1>)<EOL>)<EOL>)<EOL>)<EOL><DEDENT>for node in self.node.values():<EOL><INDENT>try:<EOL><INDENT>(x, y, z) = node.name<EOL><DEDENT>except ValueError:<EOL><INDENT>try:<EOL><INDENT>(x, y) = node.name<EOL>z = <NUM_LIT:0.0><EOL><DEDENT>except ValueError:<EOL><INDENT>try:<EOL><INDENT>x = node['<STR_LIT:x>']<EOL>y = node['<STR_LIT:y>']<EOL>z = node.get('<STR_LIT:z>', <NUM_LIT:0.0>)<EOL><DEDENT>except KeyError:<EOL><INDENT>continue<EOL><DEDENT><DEDENT><DEDENT>x, y, z = map(float, (x, y, z))<EOL>node[stat] = noise(x, y, z)<EOL><DEDENT>return self<EOL>
|
Apply Perlin noise to my nodes, and return myself.
I'll try to use the name of the node as its spatial position
for this purpose, or use its stats 'x', 'y', and 'z', or skip
the node if neither are available. z is assumed 0 if not
provided for a node.
Result will be stored in a node stat named 'perlin' by default.
Supply the name of another stat to use it instead.
|
f9037:c1:m29
|
def copy_from(self, g):
|
renamed = {}<EOL>for k, v in g.node.items():<EOL><INDENT>ok = k<EOL>if k in self.place:<EOL><INDENT>n = <NUM_LIT:0><EOL>while k in self.place:<EOL><INDENT>k = ok + (n,) if isinstance(ok, tuple) else (ok, n)<EOL>n += <NUM_LIT:1><EOL><DEDENT><DEDENT>renamed[ok] = k<EOL>self.place[k] = v<EOL><DEDENT>if type(g) is nx.MultiDiGraph:<EOL><INDENT>g = nx.DiGraph(g)<EOL><DEDENT>elif type(g) is nx.MultiGraph:<EOL><INDENT>g = nx.Graph(g)<EOL><DEDENT>if type(g) is nx.DiGraph:<EOL><INDENT>for u, v in g.edges:<EOL><INDENT>self.edge[renamed[u]][renamed[v]] = g.adj[u][v]<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert type(g) is nx.Graph<EOL>for u, v, d in g.edges.data():<EOL><INDENT>self.add_portal(renamed[u], renamed[v], symmetrical=True, **d)<EOL><DEDENT><DEDENT>return self<EOL>
|
Copy all nodes and edges from the given graph into this.
Return myself.
|
f9037:c1:m30
|
def become(self, g):
|
self.clear()<EOL>self.copy_from(g)<EOL>return self<EOL>
|
Erase all my nodes and edges. Replace them with a copy of the graph
provided.
Return myself.
|
f9037:c1:m31
|
def grid_2d_8graph(self, m, n):
|
me = nx.Graph()<EOL>node = me.node<EOL>add_node = me.add_node<EOL>add_edge = me.add_edge<EOL>for i in range(m):<EOL><INDENT>for j in range(n):<EOL><INDENT>add_node((i, j))<EOL>if i > <NUM_LIT:0>:<EOL><INDENT>add_edge((i, j), (i-<NUM_LIT:1>, j))<EOL>if j > <NUM_LIT:0>:<EOL><INDENT>add_edge((i, j), (i-<NUM_LIT:1>, j-<NUM_LIT:1>))<EOL><DEDENT><DEDENT>if j > <NUM_LIT:0>:<EOL><INDENT>add_edge((i, j), (i, j-<NUM_LIT:1>))<EOL><DEDENT>if (i - <NUM_LIT:1>, j + <NUM_LIT:1>) in node:<EOL><INDENT>add_edge((i, j), (i-<NUM_LIT:1>, j+<NUM_LIT:1>))<EOL><DEDENT><DEDENT><DEDENT>return self.copy_from(me)<EOL>
|
Make a 2d graph that's connected 8 ways, enabling diagonal movement
|
f9037:c1:m39
|
def cull_nodes(self, stat, threshold=<NUM_LIT:0.5>, comparator=ge):
|
comparator = self._lookup_comparator(comparator)<EOL>dead = [<EOL>name for name, node in self.node.items()<EOL>if stat in node and comparator(node[stat], threshold)<EOL>]<EOL>self.remove_nodes_from(dead)<EOL>return self<EOL>
|
Delete nodes whose stat >= ``threshold`` (default 0.5).
Optional argument ``comparator`` will replace >= as the test
for whether to cull. You can use the name of a stored function.
|
f9037:c1:m90
|
def cull_portals(self, stat, threshold=<NUM_LIT:0.5>, comparator=ge):
|
comparator = self._lookup_comparator(comparator)<EOL>dead = []<EOL>for u in self.portal:<EOL><INDENT>for v in self.portal[u]:<EOL><INDENT>if stat in self.portal[u][v] and comparator(<EOL>self.portal[u][v][stat], threshold<EOL>):<EOL><INDENT>dead.append((u, v))<EOL><DEDENT><DEDENT><DEDENT>self.remove_edges_from(dead)<EOL>return self<EOL>
|
Delete portals whose stat >= ``threshold`` (default 0.5).
Optional argument ``comparator`` will replace >= as the test
for whether to cull. You can use the name of a stored function.
|
f9037:c1:m91
|
def cull_edges(self, stat, threshold=<NUM_LIT:0.5>, comparator=ge):
|
return self.cull_portals(stat, threshold, comparator)<EOL>
|
Delete edges whose stat >= ``threshold`` (default 0.5).
Optional argument ``comparator`` will replace >= as the test
for whether to cull. You can use the name of a stored function.
|
f9037:c1:m92
|
def __init__(self, character, rulebook, booktyp):
|
super().__init__(rulebook.engine, rulebook)<EOL>self.character = character<EOL>self._table = booktyp + "<STR_LIT>"<EOL>
|
Initialize as usual for the ``rulebook``, mostly.
My ``character`` property will be the one passed in, and my
``_table`` will be the ``booktyp`` with ``"_rules"`` appended.
|
f9037:c2:m0
|
def __init__(self, character, fun):
|
if not callable(fun):<EOL><INDENT>raise TypeError("<STR_LIT>")<EOL><DEDENT>self.character = character<EOL>if isinstance(fun, str):<EOL><INDENT>self.fun = self.engine.sense[fun]<EOL><DEDENT>else:<EOL><INDENT>self.fun = fun<EOL><DEDENT>
|
Store the character and the function.
Look up the function in the engine's ``sense`` function store,
if needed.
|
f9037:c4:m0
|
def __call__(self, observed):
|
if isinstance(observed, str):<EOL><INDENT>observed = self.engine.character[observed]<EOL><DEDENT>return self.fun(self.engine, self.character, Facade(observed))<EOL>
|
Call the function, prefilling the engine and observer arguments.
|
f9037:c4:m1
|
def __init__(self, container, sensename):
|
self.container = container<EOL>self.sensename = sensename<EOL>
|
Store the container and the name of the sense.
|
f9037:c5:m0
|
@property<EOL><INDENT>def func(self):<DEDENT>
|
fn = self.engine.query.sense_func_get(<EOL>self.observer.name,<EOL>self.sensename,<EOL>*self.engine._btt()<EOL>)<EOL>if fn is not None:<EOL><INDENT>return SenseFuncWrap(self.observer, fn)<EOL><DEDENT>
|
Return the function most recently associated with this sense.
|
f9037:c5:m1
|
def __call__(self, observed):
|
r = self.func(observed)<EOL>if not (<EOL>isinstance(r, Character) or<EOL>isinstance(r, Facade)<EOL>):<EOL><INDENT>raise TypeError(<EOL>"<STR_LIT>"<EOL>)<EOL><DEDENT>return r<EOL>
|
Call my sense function and make sure it returns the right type,
then return that.
|
f9037:c5:m2
|
def __init__(self, character):
|
super().__init__()<EOL>self.character = character<EOL>
|
Store the character.
|
f9037:c6:m0
|
def __iter__(self):
|
yield from self.engine.query.sense_active_items(<EOL>self.character.name, *self.engine._btt()<EOL>)<EOL>
|
Iterate over active sense names.
|
f9037:c6:m1
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.