Skip to content

Control Flow#

CaptureGraph supports conditional logic and branching through control flow nodes and operator overloading.

Conditional Execution#

IfThenElse#

Branch based on a boolean condition using IfThenElse:

import capturegraph.procedures as cgp

result = cgp.IfThenElse(
    condition=is_advanced_user,
    true_branch=advanced_workflow(),
    false_branch=simple_workflow()
)

Nested Conditions#

For multiple conditions, nest IfThenElse or use switch cases:

result = cgp.IfThenElse(
    condition=condition_a,
    true_branch=handle_a(),
    false_branch=cgp.IfThenElse(
        condition=condition_b,
        true_branch=handle_b(),
        false_branch=handle_default()
    )
)

Switch Cases#

For multiple branches, use the switch case toolkit:

import capturegraph.procedures as cgp

result = cgp.switch_case_strings(
    case=user_selection,
    cases={
        "Photo": capture_photo_procedure(),
        "Video": capture_video_procedure(),
        "Audio": capture_audio_procedure(),
    },
    default=skip_procedure()
)

User Selection#

Combine user input with branching using user_select_procedure:

import capturegraph.procedures as cgp

# One-time selection
result = cgp.user_select_procedure(
    label="What would you like to capture?",
    options={
        "Take Photo": capture_photo(),
        "Record Notes": capture_notes(),
        "Skip": cgp.DoNothing(),
    }
)

# Persistent selection (remembered across sessions)
result = cgp.cached_user_select_procedure(
    label="Default capture mode",
    options={...},
    file=target.new_file("mode_preference"),
    skip_if_exists=True
)

Operator Overloading#

CaptureGraph supports Python operators for cleaner boolean and numeric logic. See the Operators API.

Boolean Operators#

Use & (AND), | (OR), and ~ (NOT) on Procedure[PBool]:

# Verbose
condition = cgp.BoolAnd(left=cond_a, right=cgp.BoolNot(input=cond_b))

# Fluent
condition = cond_a & ~cond_b

# Complex expressions
can_proceed = (is_valid & has_permission) | is_admin

Comparison Operators#

Use <, >, <=, >= on Procedure[PNumber]:

# Verbose
is_high = cgp.NumberLessThan(left=threshold, right=value)

# Fluent
is_high = value > threshold

# Range check
in_range = (value > min_val) & (value < max_val)

Equality#

Use == for string or value comparison:

is_advanced = user_mode == cgp.ConstantString(value="advanced")

Complete Example#

import capturegraph.procedures as cgp

def adaptive_procedure():
    target = cgp.GetRootDirectory()
    session = target.new_session("capture")

    # Get user's experience level (cached)
    experience = cgp.cached_user_select_procedure(
        label="Your experience level",
        options={
            "Beginner": cgp.ConstantString(value="beginner"),
            "Advanced": cgp.ConstantString(value="advanced"),
        },
        file=target.new_file("experience"),
        skip_if_exists=True
    )

    # Check conditions
    is_first = ~cgp.ProcedureCompleted(
        procedure=target.get_first_session("capture")
    )
    is_advanced = experience == cgp.ConstantString(value="advanced")

    # Adaptive workflow
    return cgp.IfThenElse(
        condition=is_first | ~is_advanced,
        true_branch=guided_workflow(session),
        false_branch=quick_workflow(session)
    )

See Also#