Changeset 15

Timestamp:

10/12/04 14:54:25

Author:

fumanchu

Message:

1. Doc updates (modeling.html)
2. Added or_combine to logic.Aggregator, or to logic.Expression

Files:

• trunk/__init__.py (modified) (4 diffs)
• trunk/doc/index.html (modified) (1 diff)
• trunk/doc/modeling.html (modified) (6 diffs)
• trunk/logic.py (modified) (2 diffs)

trunk/__init__.py

@@ -646 +646 @@
-            return None
-    
-field
+attr
-        """Recall distinct Unit property values.
-        
-field
-field
+attribute
+attribute
-        
-        Notice that you can also use this function as a count() function
-field
+attr
-        """
-        seen = {}
@@ -659 +659 @@
-        for unit in cache.itervalues():
-            if expr is None or expr.evaluate(unit):
-field) for field in field
+attr) for attr in attr
-                if row not in seen:
-                    seen[row] = None
@@ -665 +665 @@
-        store = self.arena.storage(cls)
-        if store:
-field
+attr
-                if row not in seen:
-                    seen[row] = None
@@ -671 +671 @@
-        seen = seen.keys()
-        seen.sort()
-field
+attr
-            seen = [x[0] for x in seen]
-        return seen

trunk/doc/index.html

@@ -25 +25 @@
-<li><a href='modeling.html'>Application Developers: Using Dejavu to construct a model</a>
-    <ul>
-Declaring the Unit Clas
+Unit
-        <ul>
-        <li>UnitProperty</li>
+        <li>Creating and Populating Properties</li>
+        <li>Unit Properties are First-Class Objects</li>
+        <li>Triggers</li>
+        <li>Unit ID's</li>
+        <li>Registration of Unit Classes</li>
-        </ul>
-    </li>
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    </ul>
+</li>
-<li><a href='storage.html'>Deployers: Configuring Storage</a>
-</li>

trunk/doc/modeling.html

@@ -193 +193 @@
-not fire.</p>
-
+<p>You may define special methods on your Units to provide start-of-life
+behaviors. If a Unit possesses an <tt>on_memorize</tt> method, it will
+be called after the Unit has been 'reserved' in storage, and after the
+Unit has ben placed in the Sandbox cache.</p>
+
-<h4>Sequencing</h4>
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-<h4>Recalling</h4>
@@ -239 +259 @@
-(although the rest are probably loaded into memory).</p>
-
+<h4>Forgetting and Repressing</h4>
+<p>To <i>forget</i> a Unit is to destroy it forever. You have two options
+for forgetting Units: you can call <tt>Sandbox().forget(unit)</tt> or
+the simpler version, <tt>Unit().forget()</tt>. Either of these will clear
+the Unit from the Sandbox' cache, and the Sandbox will tell the appropriate
+Storage Manager to destroy the stored Unit data. If a Unit has not yet
+been memorized, you do not need to forget it.</p>
+
+<p>In some circumstances, you may wish to only clear the Unit from the
+Sandbox without destroying it. You can do this by calling either
+<tt>Sandbox().repress(unit)</tt> or the simpler version,
+<tt>Unit().repress()</tt>.</p>
+
+<p>You may define special methods on your Units to provide end-of-life
+behaviors. If a Unit possesses an <tt>on_forget</tt> method, it will
+be called after the Unit has been destroyed. If a Unit possesses an
+<tt>on_repress</tt> method, it will be called <i>before</i> the Unit
+has been repressed. I'm sure there was a good reason for this
+disparity, but I've forgotten (or perhaps repressed) it.</p>
+
+<h4>Flushing Sandboxes</h4>
+<p>When the client connection has closed, you should <i>flush</i> the
+Sandbox caches. In general, a single call to <tt>flush_all()</tt> will do
+the trick. Notice that flushing calls <tt>repress()</tt> for each Unit in
+the Sandbox, and any <tt>on_repress()</tt> triggers will be executed.</p>
+
+<h4>Aggregate Functions</h4>
+<p>Sandboxes also provide a <tt>distinct(cls, attrs, expr=None)</tt>
+function. This returns values, rather than Units. Put simply, it returns
+all distinct values for the given attribute(s) of the Unit class provided.
+If only one attribute is specified, a list of values will be returned.
+If more than one attribute is specified, a zipped list will be returned
+of all distinct existing combinations. Providing an expr argument (an 
+<tt>Expression</tt> object, see below) will filter the set of Units before
+obtaining distinct values.</p>
+
+<p>The <tt>distinct</tt> function can also be used as a <tt>count</tt>
+function by passing attrs = ['ID']. Sandboxes provide a
+<tt>count(cls, expr)</tt> method which does just this.</p>
+
-<h3>Querying</h3>
-<p>When you retrieve Units, you often don't want to load the entire set for
@@ -245 +305 @@
-the filter you intend. Dejavu actually provides three ways.</p>
-
-Expression
+The <tt>Expression</tt> clas
-<p>Regardless of which technique you use to express your filter, you're
-going to end up with a <tt>logic.Expression</tt> object. You can build
@@ -255 +315 @@
->>> e
-logic.Expression(lambda x: x.Date >= datetime.date(2004, 3, 1))</pre>
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-<pre>>>> import dis
->>> dis.dis(f)
@@ -295 +366 @@
-globals into the <tt>logic</tt> module. Note that the <tt>logic</tt> module
-already tries to import <tt>datetime</tt>, <tt>fixedpoint</tt> and
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-<tt>comparison</tt> factory functions.</p>
+
+<p>The <tt>filter(**kwargs)</tt> function produces an Expression by taking
+the keyword arguments you supply, and rewriting them in lambda form. The 
+only operator allowed is therefore the equals '==' operator. For example:
+<pre>>>> logic.filter(Type='Cat', Mutation='Atomic')
+logic.Expression(lambda x: (x.Type == 'Cat') and (x.Mutation == 'Atomic'))</pre>
+</p>
+
+<p>The <tt>comparison(attr, cmp_op, criteria)</tt> function allows you to
+form Expressions with dynamic operators. This can come in handy when you
+are constructing Expressions on the fly from user input. For example, a
+search page might prompt users for an attribute name, an operator, and an
+operand (the criteria).</p>
+
+<p>Borrowing from <tt>opcode.cmp_op</tt>, the allowed values for our cmp_op
+argument are as follows:</p>
+<table>
+<tr><th>Numeric Value (cmp_op)</th><th>Operator</th></tr>
+<tr><td>0</td><td>&lt;</td></tr>
+<tr><td>1</td><td>&lt;=</td></tr>
+<tr><td>2</td><td>==</td></tr>
+<tr><td>3</td><td>!=</td></tr>
+<tr><td>4</td><td>&gt;</td></tr>
+<tr><td>5</td><td>&gt;=</td></tr>
+<tr><td>6</td><td>in</td></tr>
+<tr><td>7</td><td>not in</td></tr>
+<tr><td>8</td><td>is</td></tr>
+<tr><td>9</td><td>is not</td></tr>
+</table>
+
+<p>Here's an example of using <tt>comparison</tt>:
+<pre>>>> logic.comparison('Name', 3, 'Mr. Kamikaze')
+logic.Expression(lambda x: x.Name != 'Mr. Kamikaze')</pre>
+Although the comparison function only allows a single comparison at a time,
+the resulting Expressions can be combined with the <tt>&</tt> and <tt>|</tt>
+operators (described earlier) to produce more complex Expressions.</p>
+
+<h4>Exporting the <tt>logic</tt> module</h4>
+<p>The <tt>logic</tt> module (and <tt>codewalk</tt>, on which it is built)
+isn't limited to Dejavu. Feel free to use it in some other framework or
+script! The only change you may have to make (if you relocate the module
+outside of the <tt>dejavu</tt> package) would be to the single line:
+<tt>from dejavu import codewalk</tt>, to point to the new location.</p>
+
+<p>In particular, <tt>logic.Expression</tt> objects can operate on <i>any</i>
+Python object, not just dejavu <tt>Unit</tt> instances. If you wish to
+provide additional logic functions (as dejavu does), simply inject them
+into <tt>logic</tt>'s globals.</p>
+
+<p>You may also find the underlying <tt>codewalk</tt> module useful for
+other purposes on its own. The <tt>Visitor</tt> base class can be very
+convenient for building bytecode hacks.</p>
+
+<p>To make a long story short, Dejavu depends on <tt>logic</tt> throughout,
+but the reverse is not true.</p>
+
+
+<h3>Unit Engines</h3>
+<p></p>
+
+
+<h3>Analysis Tools</h3>
+<p></p>
+
-
-<h3>The Arena Object</h3>
@@ -314 +527 @@
-<p></p>
-
-<h3>Unit Engines</h3>
-<p></p>
-
-<h3>Analysis Tools</h3>
-<p></p>
-
-<br />
-

trunk/logic.py

@@ -187 +187 @@
-        self.instr_index[-1:] = [obj] * (newtarget + 4)
-    
+    def or_combine(self, obj):
+        obj = codewalk.Rewriter(obj)
+        bytecode = map(ord, obj.co_code)
+        newtarget = len(bytecode)
+        
+        self._bytecode.pop()
+        self._bytecode.extend([112, newtarget & 0xFF, newtarget >> 8,
+                               1])
+        self._bytecode.extend(bytecode)
+        self.instr_index[-1:] = [obj] * (newtarget + 4)
+    
-    def visit_LOAD_ATTR(self, lo, hi):
-        src = self.instr_index[self.cursor]
@@ -233 +244 @@
-        return 'logic.Expression(%s)' % self.code()
-    
-d
+n
-        """Logical-and this Expression with another."""
-        assert isinstance(other, Expression)
-        ag = Aggregator(self.func)
-        ag.and_combine(other.func)
+        agfunc = ag.function()
+        return Expression(agfunc)
+    __add__ = __and__
+    
+    def __or__(self, other):
+        """Logical-or this Expression with another."""
+        assert isinstance(other, Expression)
+        ag = Aggregator(self.func)
+        ag.or_combine(other.func)
-        agfunc = ag.function()
-        return Expression(agfunc)