Core Python Language Support


This section is a work in progress. It may not reflect the capabilities provided in the latest version of DaCe.

This document describes in detail which features of Python are supported by the Data-Centric Python-Frontend. The comparison is made against the Python Language Reference.

2 Lexical Analysis

2.1 Line Structure

The DaCe Python-Frontend uses the Python AST module to parse code. Therefore, full support of the line structure section is expected. However, we explicitly test for the following subsections (see line_structure_test):


  • 2.1.5 Explicit Line Joining

  • 2.1.6 Implicit Line Joining

  • 2.1.7 Blank Lines

2.3 Identifiers and Keywords

The DaCe Python-Frontend uses exactly the same rules for identifiers as normal Python. However, for a generated SDFG to compile to a target architecture, the identifiers used must be valid in the output language (e.g., C/C++). We currently provide no automatic transformation of identifiers used as variable names. Therefore, it is the responsibility of the user to ensure that the variable names are compatible.

2.3.1 Keywords:

The following keywords are recognized (for at least a subset of their Python functionality):

  • True, False, None

  • or, and, not

  • if, elif, else

  • for, while, break, continue, in

  • def, return, lambda, with

The following keywords are NOT accepted:

  • global, nonlocal

  • class

  • try, except, finally

  • raise, yield, pass

  • import, from, as

  • assert, async, await, del

2.3.2 Reserved classes of identifiers:

Reserved class of Python identifiers are not supported. Furthermore, identifiers starting with double underscore (__) are reserved by the SDFG language.

2.4 Literals

The DaCe Python-Frontend supports in general the same literals as Python. However, there is currently limited support for strings and char/byte arrays. For example, it is not possible to instantiate an (u)int8 array with a string or byte literal.

2.5 Operators

The DaCe Python-Frontend supports all Python operators. The operators are only supported in the context of arithmetic/logical operations among scalar values and DaCe (NumPy-compatible) arrays. For example, it is not possible to concatenate 2 strings with the + operator. The := operator (Named Expression) is parsed as an assignment statement.

2.6 Delimiters

The DaCe Python-Frontend supports all Python delimiters. However, not all uses of those delimiters are supported. For example, we do not support lists, sets, and dictionaries. Therefore, the delimiters [, ], {, } cannot be used to define those datatypes.

6 Expressions

6.1 Arithmetic Conversions

The arithmetic conversions for most binary operators are implemented with casting:

  • If any of the operands is of complex type, but the other operand is a float, int or bool, then it is cast to the same complex type.

  • If any of the operands is of float type, but the other operand is int or bool, the it is cast to the same float type.

Some binary operations are handled differently, as described in the sections below.

6.2 Atoms

All Python atoms are parsed. However, their intended usage may not be supported:

  • Identifiers: Supported

  • Literals: Only use of numerical literals supported

  • Parethesized forms: Some uses of tuples supported

  • Displays for lists, sets and dictionaries: Unsupported

  • List displays: Supported only for (supported) method arguments that expect a list/tuple

  • Set displays: Unsupported

  • Dictionary displays: Unsupported

  • Generator expressions: Only the built-in range supported

  • Yield expressions: Unsupported

6.3 Primaries

Similarly to atoms, Python primaries are parsed. However, their intended usage may not be supported:

  • Attribute references: Supported for a subset of the DaCe and Numpy modules

  • Subscripts: Supported on DaCe/Numpy arrays

  • Slicing: Supported on DaCe/Numpy arrays

  • Calls: Supported for other DaCe programs, and a subset of methods from the DaCe and NumPy modules

One caveat of subscripts with NumPy arrays is that NumPy allows negative indices to wrap around the array. In DaCe this is not supported.

6.4 Await expression


6.5 The power (**) operator

Supported. If the base is an integer and the exponent a signed integer, both operands are cast to float64 and the result is also of type float64.

6.6 Unary arithmetic and bitwise operations


6.7 Binary arithmetic operations

Supported. Notable differences compared to the expected Python result:

  • Modulo operator always returns a natural number (like in C/C++)

6.8 Shifting operations

Only integral types supported.

6.9 Binary bitwise operations

Only integral types supported.

6.10 Comparisons


6.11 Boolean operations


6.12 Assignment expressions

Experimental support

6.13 Conditional expressions


6.14 Lambdas

Supported only for defining WCR/reduction operators

6.15 Expression lists

Supported only for (supported) method arguments that expect a list/tuple

6.16 Evaluation order


6.17 Operator precedence

Evaluated exactly as in Python.

7 Simple Statements

7.1 Expression statements

Partially supported, as described in the previous section. Python interactive mode is not supported.

7.2 Assignment statements

Assignment statements with single or multiple targets are supported, both with and without parentheses. Statements with starred targets are not supported. Targets may only be identifiers, and subscriptions/slices of Numpy arrays.

7.2.1 Augmented assignment statements:

Supported with the same constraints for targets as in assignment statements.

7.2.2 Annotated assignment statements:


7.3 The assert statement


7.4 The pass statement


7.5 The del statement


7.6 The return statement


7.7 The yield statement


7.8 The raise statement


7.9 The break statement

Supported for for/while loops, as long as the break statement is in the same SDFG-level as the for/while statement.

7.10 The continue statement

Supported for for/while loops, as long as the continue statement is in the same SDFG-level as the for/while statement.

7.11 The import statement

Unsupported, including 7.11.1 Future statements

7.12 The global statement


7.13 The nonlocal statement


8 Compound Statements

8.1 The if statement

Supported. Note that if the type of some variable depends on the branch taken, then the variable will always have the type of the first branch. E.g., in the following code, variable b will be of type always, even if a[0] == np.float32(np.pi), unless it is explicitly declared as such:

def single_target(a: dace.float32[1]):
    if (a[0] < 0):
        b = 0
    elif (a[0] < 1):
        b = 1
        b = a
    return b

8.2 The while statement


8.3 The for statement

Supported, but only with range, parrange, and

8.4 The try statement


8.5 The with statement

Only supported with dace.tasklet

8.6 Function definitions

Supported only with the dace.program decorator. Function arguments must be type-annotated. Nested dace.program definitions are not supported.

8.7 Class definitions

Supported through the Preprocessing component of the Python frontend.

8.8 Coroutines