Add interface to check whether in a DaCe parsing context

dace/frontend/python/README.md

@@ -11,21 +11,27 @@ also address any questions you have to alziogas@inf.ethz.ch
 
 ## Supported Python Versions
 
-The DaCe framework officially supports Python 3 up to version 3.7.
-The Python-Frontend also works with version 3.8. However, the module SymPy
+The DaCe framework officially supports Python 3 from version 3.7.
+The Python-Frontend also works with version 3.8-3.10. However, the module SymPy
 must be updated to version 1.6.2 or newer. Please note that there are some
 issues between DaCe and SymPy 1.6.2 (see [#367](https://github.com/spcl/dace/pull/367)).  
 
-**Neither the DaCe framework nor the Python-Frontend have been tested with
-Python version 3.9**
-
 ## Main Limitations
 
-- Classes are not supported.
+- Classes are only supported in JIT mode.
 - Lists, sets, and dictionaries are not supported as data. There is limited support for other uses, e.g., as arguments to some methods.
 - Only `range`, `parrange`, and `dace.map` iterators are supported.
 - Recursion is not supported.
 
+## Automatic parsing
+
+By default, DaCe tries to parse every call as a dace.program. If the object being called has an `__sdfg__` method, it will
+be used instead of trying to parse `__call__`. Additionally, a function called `dace.in_program()` returns `True` while in a
+DaCe parsing context.
+
+If parsing fails, DaCe will try to automatically generate a callback to the Python interpreter, marshalling types such
+as NumPy/CuPy arrays such that they match internal data containers. A warning will also be raised when this happens.
+
 ## NumPy Compatibility
 
 The Python-Frontend currently supports a limited subset of NumPy:

dace/frontend/python/interface.py

@@ -1,12 +1,13 @@
 # Copyright 2019-2021 ETH Zurich and the DaCe authors. All rights reserved.
 """ Python interface for DaCe functions. """
 
-from functools import wraps
 import inspect
+from functools import wraps
+from typing import Any, Callable, Deque, Dict, Generator, Optional, Tuple, TypeVar, Union, overload
+
 from dace import dtypes
 from dace.dtypes import paramdec
-from dace.frontend.python import parser, ndloop, tasklet_runner
-from typing import (Any, Callable, Deque, Dict, Generator, Optional, Tuple, TypeVar, overload, Union)
+from dace.frontend.python import ndloop, parser, tasklet_runner
 
 #############################################
 
@@ -226,9 +227,19 @@ def unroll(generator):
     """
     yield from generator
 
+
 def nounroll(generator):
     """
     Explicitly annotates that a loop should not be unrolled during parsing.
     :param generator: The original generator to loop over.
     """
     yield from generator
+
+
+def in_program() -> bool:
+    """
+    Returns True if in a DaCe program parsing context. This function can be used to test whether the current
+    code runs inside the ``@dace.program`` parser.
+    :return: True if in a DaCe program parsing context, or False otherwise.
+    """
+    return False

dace/frontend/python/parser.py

@@ -47,7 +47,7 @@ def _get_locals_and_globals(f):
     """ Retrieves a list of local and global variables for the function ``f``.
         This is used to retrieve variables around and defined before  @dace.programs for adding symbols and constants.
     """
-    result = {}
+    result = {'__dace__': True}
     # Update globals, then locals
     result.update(f.__globals__)
     # grab the free variables (i.e. locals)
@@ -77,6 +77,7 @@ def infer_symbols_from_datadescriptor(sdfg: SDFG, args: Dict[str, Any],
     exclude = set(symbolic.symbol(s) for s in exclude)
     equations = []
     symbols = set()
+
     # Collect equations and symbols from arguments and shapes
     for arg_name, arg_val in args.items():
         if arg_name in sdfg.arrays:

dace/frontend/python/preprocessing.py

@@ -579,12 +579,22 @@ def visit_Subscript(self, node: ast.Subscript) -> Any:
         return self.visit_Attribute(node)
 
     def visit_Call(self, node: ast.Call) -> Any:
+        from dace.frontend.python.interface import in_program  # Avoid import loop
+
         if hasattr(node.func, 'n') and isinstance(node.func.n, SDFGConvertible):
             # Skip already-parsed calls
             return self.generic_visit(node)
 
         try:
             global_func = astutils.evalnode(node.func, self.globals)
+
+            # Built-in functions are resolved directly
+            if global_func is in_program:
+                return self.global_value_to_node(True,
+                                                 parent_node=node,
+                                                 qualname=astutils.unparse(node),
+                                                 recurse=True)
+
             if self.resolve_functions:
                 global_val = astutils.evalnode(node, self.globals)
             else:

tests/python_frontend/parsing_context_test.py

@@ -0,0 +1,24 @@
+# Copyright 2019-2022 ETH Zurich and the DaCe authors. All rights reserved.
+import dace
+import numpy as np
+
+
+def test_parsing_context():
+    def func(a):
+        if dace.in_program():
+            a[:] = 1
+        else:
+            a[:] = 2
+
+    first = np.random.rand(10)
+    second = np.random.rand(10)
+
+    func(first)
+    dace.program(func)(second)
+
+    assert np.allclose(first, 2)
+    assert np.allclose(second, 1)
+
+
+if __name__ == '__main__':
+    test_parsing_context()