This is an automated email from the ASF dual-hosted git repository.
github-bot pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/burr.git
The following commit(s) were added to refs/heads/asf-site by this push:
new 8d848cf2 Deploy documentation from
241d6ee0c7467841ab27f905dc26d93f2b9976c2
8d848cf2 is described below
commit 8d848cf237cee2839d7232cc97e8bd57ac03e1e4
Author: GitHub Actions <[email protected]>
AuthorDate: Mon Mar 16 05:22:09 2026 +0000
Deploy documentation from 241d6ee0c7467841ab27f905dc26d93f2b9976c2
---
content/_sources/concepts/transitions.rst.txt | 34 +++++++++++++++++++++++++
content/concepts/transitions/index.html | 31 +++++++++++++++++++++++
content/reference/conditions/index.html | 36 ++++++++++++++++++++++++---
content/searchindex.js | 2 +-
4 files changed, 98 insertions(+), 5 deletions(-)
diff --git a/content/_sources/concepts/transitions.rst.txt
b/content/_sources/concepts/transitions.rst.txt
index a3338395..479ee881 100644
--- a/content/_sources/concepts/transitions.rst.txt
+++ b/content/_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/content/concepts/transitions/index.html
b/content/concepts/transitions/index.html
index 78d05ed6..20754ee3 100644
--- a/content/concepts/transitions/index.html
+++ b/content/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/content/reference/conditions/index.html
b/content/reference/conditions/index.html
index 22fca119..04207661 100644
--- a/content/reference/conditions/index.html
+++ b/content/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/content/searchindex.js b/content/searchindex.js
index 1d0d87e0..1b662cb7 100644
--- a/content/searchindex.js
+++ b/content/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
