Skip to content

Expression

Class: ExpressionBlockV1

Source: inference.core.workflows.core_steps.formatters.expression.v1.ExpressionBlockV1

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

Name Type Description Refs
name str Enter a unique identifier for this step.. ❌
data_operations Dict[str, List[Union[ClassificationPropertyExtract, ConvertDictionaryToJSON, ConvertImageToBase64, ConvertImageToJPEG, DetectionsFilter, DetectionsOffset, DetectionsPropertyExtract, DetectionsRename, DetectionsSelection, DetectionsShift, DetectionsToDictionary, Divide, ExtractDetectionProperty, ExtractFrameMetadata, ExtractImageProperty, LookupTable, Multiply, NumberRound, NumericSequenceAggregate, PickDetectionsByParentClass, RandomNumber, SequenceAggregate, SequenceApply, SequenceElementsCount, SequenceLength, SequenceMap, SortDetections, StringMatches, StringSubSequence, StringToLowerCase, StringToUpperCase, TimestampToISOFormat, ToBoolean, ToNumber, ToString]]] Optional dictionary of operations to transform data variables before condition evaluation. Keys are variable names from data, values are lists of operations (same as Property Definition block). Operations are applied to transform variables before they are used in conditions. Useful for extracting properties, filtering, or transforming data before evaluation. Empty dictionary (default) means no transformations are applied.. ❌
switch CasesDefinition Switch-case logic definition containing cases with conditions and results. Each case has a condition (StatementGroup with binary/unary statements) and a result (static value or dynamic variable). Cases are evaluated in order - first matching case's result is returned. Default result is returned if no cases match. Supports complex conditions with AND/OR operators, comparison operators (==, !=, >, <, >=, <=), string operations (contains, startsWith, endsWith), membership tests (in, any in, all in), and existence tests (Exists, is empty).. ❌

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

Available Connections

Compatible Blocks

Check what blocks you can connect to Expression in version v1.

Input and Output Bindings

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

Bindings

  • input

    • data (*): Dictionary of named variables containing data from workflow steps. Variable names are used in conditions and results. Keys are variable names, values are selectors referencing workflow step outputs. Variables can be referenced in conditions and dynamic results. Example: {'predictions': '$steps.model.predictions', 'reference': '$inputs.reference_class_names'} creates variables 'predictions' and 'reference'..

  • output

    • output (*): Equivalent of any element.
Example JSON definition of step Expression in version v1 
{
    "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"
    }
}