Expression¶

Create conditional logic and business rules in workflows using switch-case statements that evaluate conditions on input variables, optionally transform data with operations, and return different outputs based on which condition matches, enabling conditional execution, business logic implementation, rule-based decision making, and dynamic output generation workflows.

How This Block Works¶

This block implements conditional logic similar to switch-case or if-else-if statements in programming. The block:

1. Receives input data as a dictionary of named variables from workflow steps
2. Optionally applies data transformations using operations:
3. Performs operations on data variables before condition evaluation
4. Uses the same operation system as Property Definition block
5. Transforms data (e.g., extract properties, filter, select) to prepare variables for conditions
6. Stores transformed values as variables for use in conditions
7. Evaluates switch-case statements sequentially:
8. Tests each case condition in order until one matches
9. Stops at the first matching case and returns its result
10. If no case matches, returns the default result
11. Evaluates conditions using a flexible expression system:
12. Binary Statements: Compare two values using operators (==, !=, >, <, >=, <=, contains, startsWith, endsWith, in, any in, all in)
13. Unary Statements: Test single values (Exists, DoesNotExist, is True, is False, is empty, is not empty)
14. Statement Groups: Combine multiple statements with AND/OR operators for complex conditions
15. Conditions can reference variables by name (DynamicOperand) or use literal values (StaticOperand)
16. Returns results based on matched case:

Static Results: - Returns a fixed value defined in the case (e.g., "PASS", "FAIL", numeric values, strings)

Dynamic Results: - Returns a value from a variable (can reference any input variable) - Optionally applies operations to transform the variable before returning - Enables returning computed or extracted values as output

1. Handles default case:
2. If no case condition matches, returns the default result
3. Default can be static or dynamic, just like case results

The block enables complex conditional logic by combining data transformation operations with flexible condition evaluation. Conditions can compare variables, test existence, check membership, perform string operations, and combine multiple conditions with logical operators. This makes it powerful for implementing business rules, validation logic, classification based on multiple criteria, and conditional data transformation.

Common Use Cases¶

• Business Logic Implementation: Implement conditional business rules and validation logic (e.g., validate detection matches reference, implement quality checks, enforce business rules), enabling business logic workflows
• Conditional Classification: Classify data based on multiple conditions and criteria (e.g., classify detections based on properties, categorize results by conditions, implement multi-criteria classification), enabling conditional classification workflows
• Validation and Quality Control: Validate data or predictions against reference values or thresholds (e.g., validate predictions match expected classes, check quality thresholds, verify compliance), enabling validation workflows
• Rule-Based Decision Making: Make decisions based on complex rule sets (e.g., approve/reject based on multiple criteria, route data based on conditions, make decisions using rule sets), enabling rule-based decision workflows
• Dynamic Output Generation: Generate different outputs based on input conditions (e.g., return different values based on conditions, generate conditional outputs, create dynamic results), enabling dynamic output workflows
• Multi-Condition Filtering: Implement complex filtering logic with multiple conditions (e.g., filter based on multiple criteria, apply complex conditional filters, implement multi-factor filtering), enabling conditional filtering workflows

Connecting to Other Blocks¶

This block receives data from workflow steps and produces conditional output:

• After model or analytics blocks to implement conditional logic on predictions or results (e.g., validate predictions, classify results, apply conditional rules), enabling conditional logic workflows
• After Property Definition blocks to use extracted properties in conditions (e.g., use extracted values in conditions, compare extracted properties, implement logic on extracted data), enabling property-to-condition workflows
• Before logic blocks like Continue If to provide conditional inputs (e.g., provide conditional values for filtering, supply conditional inputs for decisions), enabling expression-to-logic workflows
• Before data storage blocks to conditionally format or transform data for storage (e.g., conditionally format for storage, apply conditional transformations, prepare conditional outputs), enabling conditional storage workflows
• Before notification blocks to send conditional notifications (e.g., send conditional alerts, notify based on conditions, trigger conditional notifications), enabling conditional notification workflows
• In workflow outputs to provide conditional final outputs (e.g., conditional workflow outputs, dynamic result generation, conditional output formatting), enabling conditional output workflows

Requirements¶

This block requires input data as a dictionary where keys are variable names and values are data from workflow steps. The switch parameter defines cases with conditions and results. Conditions support binary comparisons (==, !=, >, <, >=, <=, contains, in, etc.), unary tests (Exists, is empty, etc.), and logical combinations (AND/OR). Data operations are optional and use the same operation system as Property Definition block. The block evaluates cases in order and returns the result of the first matching case, or the default result if no cases match. Results can be static values or dynamic values from variables (optionally with operations applied).

Type identifier¶

Use the following identifier in step "type" field: roboflow_core/expression@v1to add the block as as step in your workflow.

Properties¶

The Refs column marks possibility to parametrise the property with dynamic values available in workflow runtime. See Bindings for more info.

Available Connections¶

Input and Output Bindings¶

The available connections depend on its binding kinds. Check what binding kinds Expression in version v1 has.

{
    "name": "<your_step_name_here>",
    "type": "roboflow_core/expression@v1",
    "data": {
        "predictions": "$steps.model.predictions",
        "reference": "$inputs.reference_class_names"
    },
    "data_operations": {
        "predictions": [
            {
                "property_name": "class_name",
                "type": "DetectionsPropertyExtract"
            }
        ]
    },
    "switch": {
        "cases": [
            {
                "condition": {
                    "statements": [
                        {
                            "comparator": {
                                "type": "=="
                            },
                            "left_operand": {
                                "operand_name": "class_name",
                                "type": "DynamicOperand"
                            },
                            "right_operand": {
                                "operand_name": "reference",
                                "type": "DynamicOperand"
                            },
                            "type": "BinaryStatement"
                        }
                    ],
                    "type": "StatementGroup"
                },
                "result": {
                    "type": "StaticCaseResult",
                    "value": "PASS"
                },
                "type": "CaseDefinition"
            }
        ],
        "default": {
            "type": "StaticCaseResult",
            "value": "FAIL"
        },
        "type": "CasesDefinition"
    }
}