This is an automated email from the ASF dual-hosted git repository.
github-bot pushed a commit to branch gh-pages
in repository https://gitbox.apache.org/repos/asf/burr.git
The following commit(s) were added to refs/heads/gh-pages by this push:
new 98833026 deploy: 241d6ee0c7467841ab27f905dc26d93f2b9976c2
98833026 is described below
commit 988330262009f843791bf5a5ef7a885fec10d796
Author: skrawcz <[email protected]>
AuthorDate: Mon Mar 16 05:21:50 2026 +0000
deploy: 241d6ee0c7467841ab27f905dc26d93f2b9976c2
---
.doctrees/concepts/transitions.doctree | Bin 13639 -> 21457 bytes
.doctrees/environment.pickle | Bin 442354 -> 442354 bytes
.doctrees/reference/conditions.doctree | Bin 59410 -> 62466 bytes
_sources/concepts/transitions.rst.txt | 34 +++++++++++++++++++++++++++++++
concepts/transitions/index.html | 31 ++++++++++++++++++++++++++++
reference/conditions/index.html | 36 +++++++++++++++++++++++++++++----
searchindex.js | 2 +-
7 files changed, 98 insertions(+), 5 deletions(-)
diff --git a/.doctrees/concepts/transitions.doctree
b/.doctrees/concepts/transitions.doctree
index e0dd334c..7143ed12 100644
Binary files a/.doctrees/concepts/transitions.doctree and
b/.doctrees/concepts/transitions.doctree differ
diff --git a/.doctrees/environment.pickle b/.doctrees/environment.pickle
index 66d75740..de588184 100644
Binary files a/.doctrees/environment.pickle and b/.doctrees/environment.pickle
differ
diff --git a/.doctrees/reference/conditions.doctree
b/.doctrees/reference/conditions.doctree
index 409ca9e4..c3cfc589 100644
Binary files a/.doctrees/reference/conditions.doctree and
b/.doctrees/reference/conditions.doctree differ
diff --git a/_sources/concepts/transitions.rst.txt
b/_sources/concepts/transitions.rst.txt
index a3338395..479ee881 100644
--- a/_sources/concepts/transitions.rst.txt
+++ b/_sources/concepts/transitions.rst.txt
@@ -54,6 +54,40 @@ Conditions have a few APIs, but the most common are the
three convenience functi
)
+``when()`` also supports comparison operators via Django-style ``__`` suffixes:
+
+.. code-block:: python
+
+ from burr.core import when
+ with_transitions(
+ ("check", "adult", when(age__gte=18)), # age >= 18
+ ("check", "child", when(age__lt=18)), # age < 18
+ ("check", "valid", when(score__gt=0, score__lte=100)), # 0 < score <=
100
+ ("check", "active", when(status__in=["active", "pending"])), #
membership
+ ("check", "tagged", when(tags__contains="python")), # collection
contains value
+ ("check", "clean", when(status__notin=["banned", "suspended"])), #
not in
+ ("check", "changed", when(status__ne="initial")), # not equal
+ ("check", "missing", when(value__is=None)), # identity check
+ ("check", "present", when(value__isnot=None)), # not-identity check
+ )
+
+Available operators:
+
+- ``key=value`` — exact equality (default, unchanged)
+- ``key__eq=value`` — explicit equality
+- ``key__ne=value`` — not equal
+- ``key__gt=value`` — greater than
+- ``key__gte=value`` — greater than or equal
+- ``key__lt=value`` — less than
+- ``key__lte=value`` — less than or equal
+- ``key__in=[values]`` — value is in the given collection
+- ``key__notin=[values]`` — value is not in the given collection
+- ``key__contains=value`` — collection/string in state contains the value
+- ``key__is=value`` — identity check (``is``), useful for
``None``/``True``/``False``
+- ``key__isnot=value`` — negated identity check (``is not``)
+
+Multiple keyword arguments are ANDed together. For more complex expressions,
use ``expr()``.
+
Conditions are evaluated in the order they are specified, and the first one
that evaluates to True will be the transition that is selected
when determining which action to run next. If no condition evaluates to
``True``, the application execution will stop early.
diff --git a/concepts/transitions/index.html b/concepts/transitions/index.html
index 78d05ed6..20754ee3 100644
--- a/concepts/transitions/index.html
+++ b/concepts/transitions/index.html
@@ -425,6 +425,37 @@ You can think of them as edges in a graph.</p>
<span class="p">)</span>
</pre></div>
</div>
+<p><code class="docutils literal notranslate"><span
class="pre">when()</span></code> also supports comparison operators via
Django-style <code class="docutils literal notranslate"><span
class="pre">__</span></code> suffixes:</p>
+<div class="highlight-python notranslate"><div
class="highlight"><pre><span></span><span class="kn">from</span><span
class="w"> </span><span class="nn">burr.core</span><span class="w">
</span><span class="kn">import</span> <span class="n">when</span>
+<span class="n">with_transitions</span><span class="p">(</span>
+ <span class="p">(</span><span class="s2">"check"</span><span
class="p">,</span> <span class="s2">"adult"</span><span
class="p">,</span> <span class="n">when</span><span class="p">(</span><span
class="n">age__gte</span><span class="o">=</span><span
class="mi">18</span><span class="p">)),</span> <span class="c1"># age
>= 18</span>
+ <span class="p">(</span><span class="s2">"check"</span><span
class="p">,</span> <span class="s2">"child"</span><span
class="p">,</span> <span class="n">when</span><span class="p">(</span><span
class="n">age__lt</span><span class="o">=</span><span class="mi">18</span><span
class="p">)),</span> <span class="c1"># age < 18</span>
+ <span class="p">(</span><span class="s2">"check"</span><span
class="p">,</span> <span class="s2">"valid"</span><span
class="p">,</span> <span class="n">when</span><span class="p">(</span><span
class="n">score__gt</span><span class="o">=</span><span
class="mi">0</span><span class="p">,</span> <span
class="n">score__lte</span><span class="o">=</span><span
class="mi">100</span><span class="p">)),</span> <span class="c1"># 0 <
score <= 100</span>
+ <span class="p">(</span><span class="s2">"check"</span><span
class="p">,</span> <span class="s2">"active"</span><span
class="p">,</span> <span class="n">when</span><span class="p">(</span><span
class="n">status__in</span><span class="o">=</span><span
class="p">[</span><span class="s2">"active"</span><span
class="p">,</span> <span class="s2">"pending"</span><span
class="p">])),</span> <span class="c1"># membership</span>
+ <span class="p">(</span><span class="s2">"check"</span><span
class="p">,</span> <span class="s2">"tagged"</span><span
class="p">,</span> <span class="n">when</span><span class="p">(</span><span
class="n">tags__contains</span><span class="o">=</span><span
class="s2">"python"</span><span class="p">)),</span> <span
class="c1"># collection contains value</span>
+ <span class="p">(</span><span class="s2">"check"</span><span
class="p">,</span> <span class="s2">"clean"</span><span
class="p">,</span> <span class="n">when</span><span class="p">(</span><span
class="n">status__notin</span><span class="o">=</span><span
class="p">[</span><span class="s2">"banned"</span><span
class="p">,</span> <span class="s2">"suspended"</span><span
class="p">])),</span> <span class="c1"># not in</span>
+ <span class="p">(</span><span class="s2">"check"</span><span
class="p">,</span> <span class="s2">"changed"</span><span
class="p">,</span> <span class="n">when</span><span class="p">(</span><span
class="n">status__ne</span><span class="o">=</span><span
class="s2">"initial"</span><span class="p">)),</span> <span
class="c1"># not equal</span>
+ <span class="p">(</span><span class="s2">"check"</span><span
class="p">,</span> <span class="s2">"missing"</span><span
class="p">,</span> <span class="n">when</span><span class="p">(</span><span
class="n">value__is</span><span class="o">=</span><span
class="kc">None</span><span class="p">)),</span> <span class="c1"># identity
check</span>
+ <span class="p">(</span><span class="s2">"check"</span><span
class="p">,</span> <span class="s2">"present"</span><span
class="p">,</span> <span class="n">when</span><span class="p">(</span><span
class="n">value__isnot</span><span class="o">=</span><span
class="kc">None</span><span class="p">)),</span> <span class="c1">#
not-identity check</span>
+<span class="p">)</span>
+</pre></div>
+</div>
+<p>Available operators:</p>
+<ul class="simple">
+<li><p><code class="docutils literal notranslate"><span
class="pre">key=value</span></code> — exact equality (default,
unchanged)</p></li>
+<li><p><code class="docutils literal notranslate"><span
class="pre">key__eq=value</span></code> — explicit equality</p></li>
+<li><p><code class="docutils literal notranslate"><span
class="pre">key__ne=value</span></code> — not equal</p></li>
+<li><p><code class="docutils literal notranslate"><span
class="pre">key__gt=value</span></code> — greater than</p></li>
+<li><p><code class="docutils literal notranslate"><span
class="pre">key__gte=value</span></code> — greater than or equal</p></li>
+<li><p><code class="docutils literal notranslate"><span
class="pre">key__lt=value</span></code> — less than</p></li>
+<li><p><code class="docutils literal notranslate"><span
class="pre">key__lte=value</span></code> — less than or equal</p></li>
+<li><p><code class="docutils literal notranslate"><span
class="pre">key__in=[values]</span></code> — value is in the given
collection</p></li>
+<li><p><code class="docutils literal notranslate"><span
class="pre">key__notin=[values]</span></code> — value is not in the given
collection</p></li>
+<li><p><code class="docutils literal notranslate"><span
class="pre">key__contains=value</span></code> — collection/string in state
contains the value</p></li>
+<li><p><code class="docutils literal notranslate"><span
class="pre">key__is=value</span></code> — identity check (<code class="docutils
literal notranslate"><span class="pre">is</span></code>), useful for <code
class="docutils literal notranslate"><span class="pre">None</span></code>/<code
class="docutils literal notranslate"><span class="pre">True</span></code>/<code
class="docutils literal notranslate"><span
class="pre">False</span></code></p></li>
+<li><p><code class="docutils literal notranslate"><span
class="pre">key__isnot=value</span></code> — negated identity check (<code
class="docutils literal notranslate"><span class="pre">is</span> <span
class="pre">not</span></code>)</p></li>
+</ul>
+<p>Multiple keyword arguments are ANDed together. For more complex
expressions, use <code class="docutils literal notranslate"><span
class="pre">expr()</span></code>.</p>
<p>Conditions are evaluated in the order they are specified, and the first one
that evaluates to True will be the transition that is selected
when determining which action to run next. If no condition evaluates to <code
class="docutils literal notranslate"><span class="pre">True</span></code>, the
application execution will stop early.</p>
<p>The <code class="docutils literal notranslate"><span
class="pre">~</span></code> operator will invert a condition. For instance:</p>
diff --git a/reference/conditions/index.html b/reference/conditions/index.html
index 22fca119..04207661 100644
--- a/reference/conditions/index.html
+++ b/reference/conditions/index.html
@@ -563,15 +563,43 @@ The result is just a key/value dictionary.</p>
<dl class="py method">
<dt class="sig sig-object py" id="burr.core.action.Condition.when">
<em class="property"><span class="k"><span
class="pre">classmethod</span></span><span class="w"> </span></em><span
class="sig-name descname"><span class="pre">when</span></span><span
class="sig-paren">(</span><em class="sig-param"><span class="o"><span
class="pre">**</span></span><span class="n"><span
class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a
class="headerlink" href="#burr.core.action.Condition.when" title="Link to this
definition">¶</a></dt>
-<dd><p>Returns a condition that checks if the given keys are in the
-state and equal to the given values.</p>
+<dd><p>Returns a condition that checks state values using optional
operators.</p>
<p>You can also refer to this as <code class="docutils literal
notranslate"><span class="pre">from</span> <span class="pre">burr.core</span>
<span class="pre">import</span> <span class="pre">when</span></code> in the
API.</p>
+<p>Basic equality (unchanged from original):</p>
+<div class="highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="n">when</span><span
class="p">(</span><span class="n">foo</span><span class="o">=</span><span
class="s2">"bar"</span><span class="p">)</span> <span
class="c1"># state["foo"] == "bar"</span>
+<span class="n">when</span><span class="p">(</span><span
class="n">foo</span><span class="o">=</span><span
class="s2">"bar"</span><span class="p">,</span> <span
class="n">baz</span><span class="o">=</span><span
class="s2">"qux"</span><span class="p">)</span> <span class="c1">#
state["foo"] == "bar" AND state["baz"] ==
"qux"</span>
+</pre></div>
+</div>
+<p>Comparison operators via <code class="docutils literal notranslate"><span
class="pre">__</span></code> suffix:</p>
+<div class="highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="n">when</span><span
class="p">(</span><span class="n">age__gt</span><span class="o">=</span><span
class="mi">18</span><span class="p">)</span> <span class="c1">#
state["age"] > 18</span>
+<span class="n">when</span><span class="p">(</span><span
class="n">age__gte</span><span class="o">=</span><span
class="mi">18</span><span class="p">)</span> <span class="c1">#
state["age"] >= 18</span>
+<span class="n">when</span><span class="p">(</span><span
class="n">age__lt</span><span class="o">=</span><span class="mi">18</span><span
class="p">)</span> <span class="c1"># state["age"] <
18</span>
+<span class="n">when</span><span class="p">(</span><span
class="n">age__lte</span><span class="o">=</span><span
class="mi">18</span><span class="p">)</span> <span class="c1">#
state["age"] <= 18</span>
+<span class="n">when</span><span class="p">(</span><span
class="n">age__ne</span><span class="o">=</span><span class="mi">0</span><span
class="p">)</span> <span class="c1"># state["age"] !=
0</span>
+<span class="n">when</span><span class="p">(</span><span
class="n">age__eq</span><span class="o">=</span><span class="mi">18</span><span
class="p">)</span> <span class="c1"># state["age"] == 18
(explicit)</span>
+</pre></div>
+</div>
+<p>Membership operators:</p>
+<div class="highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="n">when</span><span
class="p">(</span><span class="n">status__in</span><span
class="o">=</span><span class="p">[</span><span
class="s2">"a"</span><span class="p">,</span> <span
class="s2">"b"</span><span class="p">])</span> <span class="c1">#
state["status"] in ["a", "b"]</span>
+<span class="n">when</span><span class="p">(</span><span
class="n">status__notin</span><span class="o">=</span><span
class="p">[</span><span class="s2">"x"</span><span class="p">,</span>
<span class="s2">"y"</span><span class="p">])</span> <span
class="c1"># state["status"] not in ["x",
"y"]</span>
+<span class="n">when</span><span class="p">(</span><span
class="n">tags__contains</span><span class="o">=</span><span
class="s2">"python"</span><span class="p">)</span> <span
class="c1"># "python" in state["tags"]</span>
+</pre></div>
+</div>
+<p>Identity operators:</p>
+<div class="highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="n">when</span><span
class="p">(</span><span class="n">value__is</span><span class="o">=</span><span
class="kc">None</span><span class="p">)</span> <span class="c1">#
state["value"] is None</span>
+<span class="n">when</span><span class="p">(</span><span
class="n">value__isnot</span><span class="o">=</span><span
class="kc">None</span><span class="p">)</span> <span class="c1">#
state["value"] is not None</span>
+</pre></div>
+</div>
+<p>Multiple conditions are ANDed together:</p>
+<div class="highlight-default notranslate"><div
class="highlight"><pre><span></span><span class="n">when</span><span
class="p">(</span><span class="n">age__gte</span><span class="o">=</span><span
class="mi">18</span><span class="p">,</span> <span class="n">status</span><span
class="o">=</span><span class="s2">"active"</span><span
class="p">)</span> <span class="c1"># age >= 18 AND status ==
"active"</span>
+</pre></div>
+</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters<span class="colon">:</span></dt>
-<dd class="field-odd"><p><strong>kwargs</strong> – Keyword arguments of keys
and values to check – will be an AND condition</p>
+<dd class="field-odd"><p><strong>kwargs</strong> – Keyword arguments with
optional <code class="docutils literal notranslate"><span
class="pre">__operator</span></code> suffixes</p>
</dd>
<dt class="field-even">Returns<span class="colon">:</span></dt>
-<dd class="field-even"><p>A condition that checks if the given keys are in the
state and equal to the given values</p>
+<dd class="field-even"><p>A condition that checks all specified constraints
(AND)</p>
</dd>
</dl>
</dd></dl>
diff --git a/searchindex.js b/searchindex.js
index 1d0d87e0..1b662cb7 100644
--- a/searchindex.js
+++ b/searchindex.js
@@ -1 +1 @@
-Search.setIndex({"alltitles":{"1. Agent application is modeled as State +
Actions \u2013>
Graph":[[28,"agent-application-is-modeled-as-state-actions-graph"]],"1. Make
your methods async":[[6,"make-your-methods-async"]],"2. Build application
\u2013> built in checkpointing &
tracking":[[28,"build-application-built-in-checkpointing-tracking"]],"2.
Implement the is_async method":[[6,"implement-the-is-async-method"]],"3. Comes
with a UI":[[28,"comes-with-a-ui"]],"3. Use async persisters with [...]
\ No newline at end of file
+Search.setIndex({"alltitles":{"1. Agent application is modeled as State +
Actions \u2013>
Graph":[[28,"agent-application-is-modeled-as-state-actions-graph"]],"1. Make
your methods async":[[6,"make-your-methods-async"]],"2. Build application
\u2013> built in checkpointing &
tracking":[[28,"build-application-built-in-checkpointing-tracking"]],"2.
Implement the is_async method":[[6,"implement-the-is-async-method"]],"3. Comes
with a UI":[[28,"comes-with-a-ui"]],"3. Use async persisters with [...]
\ No newline at end of file
