gstaichi 1.0.1__cp310-cp310-win_amd64.whl → 2.1.0__cp310-cp310-win_amd64.whl

gstaichi/lang/ast/ast_transformers/call_transformer.py

@@ -9,6 +9,7 @@ import re
 import warnings
 from ast import unparse
 from collections import ChainMap
+from typing import Any
 
 import numpy as np
 
@@ -18,6 +19,7 @@ from gstaichi.lang import (
     matrix,
 )
 from gstaichi.lang import ops as ti_ops
+from gstaichi.lang._dataclass_util import create_flat_name
 from gstaichi.lang.ast.ast_transformer_utils import (
     ASTTransformerContext,
     get_decorator,
@@ -34,7 +36,7 @@ from gstaichi.types import primitive_types
 
 class CallTransformer:
     @staticmethod
-    def build_call_if_is_builtin(ctx: ASTTransformerContext, node, args, keywords):
+    def _build_call_if_is_builtin(ctx: ASTTransformerContext, node, args, keywords):
         from gstaichi.lang import matrix_ops  # pylint: disable=C0415
 
         func = node.func.ptr
@@ -64,7 +66,7 @@ class CallTransformer:
         return False
 
     @staticmethod
-    def build_call_if_is_type(ctx: ASTTransformerContext, node, args, keywords):
+    def _build_call_if_is_type(ctx: ASTTransformerContext, node, args, keywords):
         func = node.func.ptr
         if id(func) in primitive_types.type_ids:
             if len(args) != 1 or keywords:
@@ -82,7 +84,7 @@ class CallTransformer:
         return False
 
     @staticmethod
-    def is_external_func(ctx: ASTTransformerContext, func) -> bool:
+    def _is_external_func(ctx: ASTTransformerContext, func) -> bool:
         if ctx.is_in_static_scope():  # allow external function in static scope
             return False
         if hasattr(func, "_is_gstaichi_function") or hasattr(func, "_is_wrapped_kernel"):  # gstaichi func/kernel
@@ -92,9 +94,9 @@ class CallTransformer:
         return True
 
     @staticmethod
-    def warn_if_is_external_func(ctx: ASTTransformerContext, node):
+    def _warn_if_is_external_func(ctx: ASTTransformerContext, node):
         func = node.func.ptr
-        if not CallTransformer.is_external_func(ctx, func):
+        if not CallTransformer._is_external_func(ctx, func):
             return
         name = unparse(node.func).strip()
         warnings.warn_explicit(
@@ -120,7 +122,7 @@ class CallTransformer:
     # raw_args: [1.0, 2.0]
     # raw_keywords: {'k': <ti.Expr>}
     # return value: ['qwerty {} {} {} {} {}', 2.0, 1.0, ['__ti_fmt_value__', 2.0, '.3f'], ['__ti_fmt_value__', <ti.Expr>, '.4f'], <ti.Expr>]
-    def canonicalize_formatted_string(raw_string: str, *raw_args: list, **raw_keywords: dict):
+    def _canonicalize_formatted_string(raw_string: str, *raw_args: list, **raw_keywords: dict):
         raw_brackets = re.findall(r"{(.*?)}", raw_string)
         brackets = []
         unnamed = 0
@@ -164,14 +166,18 @@ class CallTransformer:
         return args
 
     @staticmethod
-    def expand_node_args_dataclasses(args: tuple[ast.AST, ...]) -> tuple[ast.AST, ...]:
+    def _expand_Call_dataclass_args(args: tuple[ast.stmt]) -> tuple[ast.stmt]:
+        """
+        We require that each node has a .ptr attribute added to it, that contains
+        the associated Python object
+        """
         args_new = []
         for arg in args:
             val = arg.ptr
             if dataclasses.is_dataclass(val):
                 dataclass_type = val
                 for field in dataclasses.fields(dataclass_type):
-                    child_name = f"__ti_{arg.id}_{field.name}"
+                    child_name = create_flat_name(arg.id, field.name)
                     load_ctx = ast.Load()
                     arg_node = ast.Name(
                         id=child_name,
@@ -181,13 +187,62 @@ class CallTransformer:
                         col_offset=arg.col_offset,
                         end_col_offset=arg.end_col_offset,
                     )
-                    args_new.append(arg_node)
+                    if dataclasses.is_dataclass(field.type):
+                        arg_node.ptr = field.type
+                        args_new.extend(CallTransformer._expand_Call_dataclass_args((arg_node,)))
+                    else:
+                        args_new.append(arg_node)
             else:
                 args_new.append(arg)
         return tuple(args_new)
 
     @staticmethod
-    def build_Call(ctx: ASTTransformerContext, node: ast.Call, build_stmt, build_stmts):
+    def _expand_Call_dataclass_kwargs(kwargs: list[ast.keyword]) -> list[ast.keyword]:
+        """
+        We require that each node has a .ptr attribute added to it, that contains
+        the associated Python object
+        """
+        kwargs_new = []
+        for i, kwarg in enumerate(kwargs):
+            val = kwarg.ptr[kwarg.arg]
+            if dataclasses.is_dataclass(val):
+                dataclass_type = val
+                for field in dataclasses.fields(dataclass_type):
+                    src_name = create_flat_name(kwarg.value.id, field.name)
+                    child_name = create_flat_name(kwarg.arg, field.name)
+                    load_ctx = ast.Load()
+                    src_node = ast.Name(
+                        id=src_name,
+                        ctx=load_ctx,
+                        lineno=kwarg.lineno,
+                        end_lineno=kwarg.end_lineno,
+                        col_offset=kwarg.col_offset,
+                        end_col_offset=kwarg.end_col_offset,
+                    )
+                    kwarg_node = ast.keyword(
+                        arg=child_name,
+                        value=src_node,
+                        ctx=load_ctx,
+                        lineno=kwarg.lineno,
+                        end_lineno=kwarg.end_lineno,
+                        col_offset=kwarg.col_offset,
+                        end_col_offset=kwarg.end_col_offset,
+                    )
+                    if dataclasses.is_dataclass(field.type):
+                        kwarg_node.ptr = {child_name: field.type}
+                        kwargs_new.extend(CallTransformer._expand_Call_dataclass_kwargs([kwarg_node]))
+                    else:
+                        kwargs_new.append(kwarg_node)
+            else:
+                kwargs_new.append(kwarg)
+        return kwargs_new
+
+    @staticmethod
+    def build_Call(ctx: ASTTransformerContext, node: ast.Call, build_stmt, build_stmts) -> Any | None:
+        """
+        example ast:
+        Call(func=Name(id='f2', ctx=Load()), args=[Name(id='my_struct_ab', ctx=Load())], keywords=[])
+        """
         if get_decorator(ctx, node) in ["static", "static_assert"]:
             with ctx.static_scope_guard():
                 build_stmt(ctx, node.func)
@@ -198,7 +253,9 @@ class CallTransformer:
             # creates variable for the dataclass itself (as well as other variables,
             # not related to dataclasses). Necessary for calling further child functions
             build_stmts(ctx, node.args)
-            node.args = CallTransformer.expand_node_args_dataclasses(node.args)
+            build_stmts(ctx, node.keywords)
+            node.args = CallTransformer._expand_Call_dataclass_args(node.args)
+            node.keywords = CallTransformer._expand_Call_dataclass_kwargs(node.keywords)
             # create variables for the now-expanded dataclass members
             build_stmts(ctx, node.args)
             build_stmts(ctx, node.keywords)
@@ -223,7 +280,7 @@ class CallTransformer:
 
         if isinstance(node.func, ast.Attribute) and isinstance(node.func.value.ptr, str) and node.func.attr == "format":
             raw_string = node.func.value.ptr
-            args = CallTransformer.canonicalize_formatted_string(raw_string, *args, **keywords)
+            args = CallTransformer._canonicalize_formatted_string(raw_string, *args, **keywords)
             node.ptr = impl.ti_format(*args)
             return node.ptr
 
@@ -231,17 +288,17 @@ class CallTransformer:
             node.ptr = matrix.make_matrix(*args, **keywords)
             return node.ptr
 
-        if CallTransformer.build_call_if_is_builtin(ctx, node, args, keywords):
+        if CallTransformer._build_call_if_is_builtin(ctx, node, args, keywords):
             return node.ptr
 
-        if CallTransformer.build_call_if_is_type(ctx, node, args, keywords):
+        if CallTransformer._build_call_if_is_type(ctx, node, args, keywords):
             return node.ptr
 
         if hasattr(node.func, "caller"):
             node.ptr = func(node.func.caller, *args, **keywords)
             return node.ptr
 
-        CallTransformer.warn_if_is_external_func(ctx, node)
+        CallTransformer._warn_if_is_external_func(ctx, node)
         try:
             node.ptr = func(*args, **keywords)
         except TypeError as e:
@@ -249,7 +306,7 @@ class CallTransformer:
             error_msg = re.sub(r"\bExpr\b", "GsTaichi Expression", str(e))
             func_name = getattr(func, "__name__", func.__class__.__name__)
             msg = f"TypeError when calling `{func_name}`: {error_msg}."
-            if CallTransformer.is_external_func(ctx, node.func.ptr):
+            if CallTransformer._is_external_func(ctx, node.func.ptr):
                 args_has_expr = any([isinstance(arg, Expr) for arg in args])
                 if args_has_expr and (module == math or module == np):
                     exec_str = f"from gstaichi import {func.__name__}"

gstaichi/lang/ast/ast_transformers/function_def_transformer.py

@@ -4,6 +4,10 @@ import ast
 import dataclasses
 from typing import Any, Callable
 
+from gstaichi._lib.core.gstaichi_python import (
+    BoundaryMode,
+    DataTypeCxx,
+)
 from gstaichi.lang import (
     _ndarray,
     any_array,
@@ -13,7 +17,7 @@ from gstaichi.lang import (
     matrix,
 )
 from gstaichi.lang import ops as ti_ops
-from gstaichi.lang.argpack import ArgPackType
+from gstaichi.lang._dataclass_util import create_flat_name
 from gstaichi.lang.ast.ast_transformer_utils import (
     ASTTransformerContext,
 )
@@ -29,153 +33,127 @@ from gstaichi.types import annotations, ndarray_type, primitive_types, texture_t
 class FunctionDefTransformer:
     @staticmethod
     def _decl_and_create_variable(
-        ctx: ASTTransformerContext, annotation, name, arg_features, invoke_later_dict, prefix_name, arg_depth
+        ctx: ASTTransformerContext,
+        annotation: Any,
+        name: str,
+        this_arg_features: tuple[tuple[Any, ...], ...] | None,
+        prefix_name: str,
     ) -> tuple[bool, Any]:
         full_name = prefix_name + "_" + name
         if not isinstance(annotation, primitive_types.RefType):
             ctx.kernel_args.append(name)
-        if isinstance(annotation, ArgPackType):
-            kernel_arguments.push_argpack_arg(name)
-            d = {}
-            items_to_put_in_dict = []
-            for j, (_name, anno) in enumerate(annotation.members.items()):
-                result, obj = FunctionDefTransformer._decl_and_create_variable(
-                    ctx, anno, _name, arg_features[j], invoke_later_dict, full_name, arg_depth + 1
-                )
-                if not result:
-                    d[_name] = None
-                    items_to_put_in_dict.append((full_name + "_" + _name, _name, obj))
-                else:
-                    d[_name] = obj
-            argpack = kernel_arguments.decl_argpack_arg(annotation, d)
-            for item in items_to_put_in_dict:
-                invoke_later_dict[item[0]] = argpack, item[1], *item[2]
-            return True, argpack
         if annotation == annotations.template or isinstance(annotation, annotations.template):
+            assert ctx.global_vars is not None
             return True, ctx.global_vars[name]
         if isinstance(annotation, annotations.sparse_matrix_builder):
             return False, (
                 kernel_arguments.decl_sparse_matrix,
                 (
-                    to_gstaichi_type(arg_features),
+                    to_gstaichi_type(this_arg_features),
                     full_name,
                 ),
             )
         if isinstance(annotation, ndarray_type.NdarrayType):
+            assert this_arg_features is not None
+            raw_element_type: DataTypeCxx
+            ndim: int
+            needs_grad: bool
+            boundary: BoundaryMode
+            raw_element_type, ndim, needs_grad, boundary = this_arg_features
             return False, (
                 kernel_arguments.decl_ndarray_arg,
                 (
-                    to_gstaichi_type(arg_features[0]),
-                    arg_features[1],
+                    to_gstaichi_type(raw_element_type),
+                    ndim,
                     full_name,
-                    arg_features[2],
-                    arg_features[3],
+                    needs_grad,
+                    boundary,
                 ),
             )
         if isinstance(annotation, texture_type.TextureType):
-            return False, (kernel_arguments.decl_texture_arg, (arg_features[0], full_name))
+            assert this_arg_features is not None
+            return False, (kernel_arguments.decl_texture_arg, (this_arg_features[0], full_name))
         if isinstance(annotation, texture_type.RWTextureType):
+            assert this_arg_features is not None
             return False, (
                 kernel_arguments.decl_rw_texture_arg,
-                (arg_features[0], arg_features[1], arg_features[2], full_name),
+                (this_arg_features[0], this_arg_features[1], this_arg_features[2], full_name),
             )
         if isinstance(annotation, MatrixType):
-            return True, kernel_arguments.decl_matrix_arg(annotation, name, arg_depth)
+            return True, kernel_arguments.decl_matrix_arg(annotation, name)
         if isinstance(annotation, StructType):
-            return True, kernel_arguments.decl_struct_arg(annotation, name, arg_depth)
-        return True, kernel_arguments.decl_scalar_arg(annotation, name, arg_depth)
+            return True, kernel_arguments.decl_struct_arg(annotation, name)
+        return True, kernel_arguments.decl_scalar_arg(annotation, name)
 
     @staticmethod
     def _transform_kernel_arg(
         ctx: ASTTransformerContext,
-        invoke_later_dict: dict[str, tuple[Any, str, Callable, list[Any]]],
-        create_variable_later: dict[str, Any],
         argument_name: str,
         argument_type: Any,
         this_arg_features: tuple[Any, ...],
     ) -> None:
-        if isinstance(argument_type, ArgPackType):
-            kernel_arguments.push_argpack_arg(argument_name)
-            d = {}
-            items_to_put_in_dict: list[tuple[str, str, Any]] = []
-            for j, (name, anno) in enumerate(argument_type.members.items()):
-                result, obj = FunctionDefTransformer._decl_and_create_variable(
-                    ctx, anno, name, this_arg_features[j], invoke_later_dict, "__argpack_" + name, 1
-                )
-                if not result:
-                    d[name] = None
-                    items_to_put_in_dict.append(("__argpack_" + name, name, obj))
-                else:
-                    d[name] = obj
-            argpack = kernel_arguments.decl_argpack_arg(argument_type, d)
-            for item in items_to_put_in_dict:
-                invoke_later_dict[item[0]] = argpack, item[1], *item[2]
-            create_variable_later[argument_name] = argpack
-        elif dataclasses.is_dataclass(argument_type):
-            arg_features = this_arg_features
+        if dataclasses.is_dataclass(argument_type):
             ctx.create_variable(argument_name, argument_type)
             for field_idx, field in enumerate(dataclasses.fields(argument_type)):
-                flat_name = f"__ti_{argument_name}_{field.name}"
-                result, obj = FunctionDefTransformer._decl_and_create_variable(
-                    ctx,
-                    field.type,
-                    flat_name,
-                    arg_features[field_idx],
-                    invoke_later_dict,
-                    "",
-                    0,
-                )
-                if result:
-                    ctx.create_variable(flat_name, obj)
+                flat_name = create_flat_name(argument_name, field.name)
+                # if a field is a dataclass, then feed back into process_kernel_arg recursively
+                if dataclasses.is_dataclass(field.type):
+                    FunctionDefTransformer._transform_kernel_arg(
+                        ctx,
+                        flat_name,
+                        field.type,
+                        this_arg_features[field_idx],
+                    )
                 else:
-                    decl_type_func, type_args = obj
-                    obj = decl_type_func(*type_args)
-                    ctx.create_variable(flat_name, obj)
+                    result, obj = FunctionDefTransformer._decl_and_create_variable(
+                        ctx,
+                        field.type,
+                        flat_name,
+                        this_arg_features[field_idx],
+                        "",
+                    )
+                    if result:
+                        ctx.create_variable(flat_name, obj)
+                    else:
+                        decl_type_func, type_args = obj
+                        obj = decl_type_func(*type_args)
+                        ctx.create_variable(flat_name, obj)
         else:
             result, obj = FunctionDefTransformer._decl_and_create_variable(
                 ctx,
                 argument_type,
                 argument_name,
                 this_arg_features if ctx.arg_features is not None else None,
-                invoke_later_dict,
                 "",
-                0,
             )
-            if result:
-                ctx.create_variable(argument_name, obj)
-            else:
+            if not result:
                 decl_type_func, type_args = obj
                 obj = decl_type_func(*type_args)
-                ctx.create_variable(argument_name, obj)
+            ctx.create_variable(argument_name, obj)
 
     @staticmethod
     def _transform_as_kernel(ctx: ASTTransformerContext, node: ast.FunctionDef, args: ast.arguments) -> None:
+        assert ctx.func is not None
+        assert ctx.arg_features is not None
         if node.returns is not None:
             if not isinstance(node.returns, ast.Constant):
+                assert ctx.func.return_type is not None
                 for return_type in ctx.func.return_type:
                     kernel_arguments.decl_ret(return_type)
-        impl.get_runtime().compiling_callable.finalize_rets()
+        compiling_callable = impl.get_runtime().compiling_callable
+        assert compiling_callable is not None
+        compiling_callable.finalize_rets()
 
-        invoke_later_dict: dict[str, tuple[Any, str, Any]] = dict()
-        create_variable_later = dict()
-        for i, arg in enumerate(args.args):
-            argument = ctx.func.arguments[i]
+        for i in range(len(args.args)):
+            arg_meta = ctx.func.arg_metas[i]
             FunctionDefTransformer._transform_kernel_arg(
                 ctx,
-                invoke_later_dict,
-                create_variable_later,
-                argument.name,
-                argument.annotation,
+                arg_meta.name,
+                arg_meta.annotation,
                 ctx.arg_features[i] if ctx.arg_features is not None else (),
             )
 
-        for k, v in invoke_later_dict.items():
-            argpack, name, func, params = v
-            argpack[name] = func(*params)
-        for k, v in create_variable_later.items():
-            ctx.create_variable(k, v)
-
-        impl.get_runtime().compiling_callable.finalize_params()
+        compiling_callable.finalize_params()
         # remove original args
         node.args.args = []
 
@@ -186,15 +164,16 @@ class FunctionDefTransformer:
         argument_type: Any,
         data: Any,
     ) -> None:
+        # Template arguments are passed by reference.
         if isinstance(argument_type, annotations.template):
             ctx.create_variable(argument_name, data)
             return None
 
         if dataclasses.is_dataclass(argument_type):
-            dataclass_type = argument_type
-            for field in dataclasses.fields(dataclass_type):
+            for field in dataclasses.fields(argument_type):
+                flat_name = create_flat_name(argument_name, field.name)
                 data_child = getattr(data, field.name)
-                if not isinstance(
+                if isinstance(
                     data_child,
                     (
                         _ndarray.ScalarNdarray,
@@ -203,33 +182,33 @@ class FunctionDefTransformer:
                         any_array.AnyArray,
                     ),
                 ):
+                    field.type.check_matched(data_child.get_type(), field.name)
+                    ctx.create_variable(flat_name, data_child)
+                elif dataclasses.is_dataclass(data_child):
+                    FunctionDefTransformer._transform_func_arg(
+                        ctx,
+                        flat_name,
+                        field.type,
+                        getattr(data, field.name),
+                    )
+                else:
                     raise GsTaichiSyntaxError(
-                        f"Argument {argument_name} of type {dataclass_type} {field.type} is not recognized."
+                        f"Argument {field.name} of type {argument_type} {field.type} is not recognized."
                     )
-                field.type.check_matched(data_child.get_type(), field.name)
-                var_name = f"__ti_{argument_name}_{field.name}"
-                ctx.create_variable(var_name, data_child)
             return None
 
         # Ndarray arguments are passed by reference.
         if isinstance(argument_type, (ndarray_type.NdarrayType)):
             if not isinstance(
-                data,
-                (
-                    _ndarray.ScalarNdarray,
-                    matrix.VectorNdarray,
-                    matrix.MatrixNdarray,
-                    any_array.AnyArray,
-                ),
+                data, (_ndarray.ScalarNdarray, matrix.VectorNdarray, matrix.MatrixNdarray, any_array.AnyArray)
             ):
-                raise GsTaichiSyntaxError(f"Argument {arg.arg} of type {argument_type} is not recognized.")
+                raise GsTaichiSyntaxError(f"Argument {argument_name} of type {argument_type} is not recognized.")
             argument_type.check_matched(data.get_type(), argument_name)
             ctx.create_variable(argument_name, data)
             return None
 
         # Matrix arguments are passed by value.
         if isinstance(argument_type, (MatrixType)):
-            var_name = argument_name
             # "data" is expected to be an Expr here,
             # so we simply call "impl.expr_init_func(data)" to perform:
             #
@@ -239,32 +218,31 @@ class FunctionDefTransformer:
             # We created local variable "t" - a copy of the passed-in argument "data"
             if not isinstance(data, expr.Expr) or not data.ptr.is_tensor():
                 raise GsTaichiSyntaxError(
-                    f"Argument {var_name} of type {argument_type} is expected to be a Matrix, but got {type(data)}."
+                    f"Argument {argument_name} of type {argument_type} is expected to be a Matrix, but got {type(data)}."
                 )
 
             element_shape = data.ptr.get_rvalue_type().shape()
             if len(element_shape) != argument_type.ndim:
                 raise GsTaichiSyntaxError(
-                    f"Argument {var_name} of type {argument_type} is expected to be a Matrix with ndim {argument_type.ndim}, but got {len(element_shape)}."
+                    f"Argument {argument_name} of type {argument_type} is expected to be a Matrix with ndim {argument_type.ndim}, but got {len(element_shape)}."
                 )
 
             assert argument_type.ndim > 0
             if element_shape[0] != argument_type.n:
                 raise GsTaichiSyntaxError(
-                    f"Argument {var_name} of type {argument_type} is expected to be a Matrix with n {argument_type.n}, but got {element_shape[0]}."
+                    f"Argument {argument_name} of type {argument_type} is expected to be a Matrix with n {argument_type.n}, but got {element_shape[0]}."
                 )
 
             if argument_type.ndim == 2 and element_shape[1] != argument_type.m:
                 raise GsTaichiSyntaxError(
-                    f"Argument {var_name} of type {argument_type} is expected to be a Matrix with m {argument_type.m}, but got {element_shape[0]}."
+                    f"Argument {argument_name} of type {argument_type} is expected to be a Matrix with m {argument_type.m}, but got {element_shape[0]}."
                 )
 
-            ctx.create_variable(var_name, impl.expr_init_func(data))
+            ctx.create_variable(argument_name, impl.expr_init_func(data))
             return None
 
         if id(argument_type) in primitive_types.type_ids:
-            var_name = argument_name
-            ctx.create_variable(var_name, impl.expr_init_func(ti_ops.cast(data, argument_type)))
+            ctx.create_variable(argument_name, impl.expr_init_func(ti_ops.cast(data, argument_type)))
             return None
         # Create a copy for non-template arguments,
         # so that they are passed by value.
@@ -274,15 +252,16 @@ class FunctionDefTransformer:
 
     @staticmethod
     def _transform_as_func(ctx: ASTTransformerContext, node: ast.FunctionDef, args: ast.arguments) -> None:
+        # pylint: disable=import-outside-toplevel
+        from gstaichi.lang.kernel_impl import Func
+
+        assert isinstance(ctx.func, Func)
+        assert ctx.argument_data is not None
         for data_i, data in enumerate(ctx.argument_data):
-            argument = ctx.func.arguments[data_i]
-            FunctionDefTransformer._transform_func_arg(
-                ctx,
-                argument.name,
-                argument.annotation,
-                data,
-            )
+            argument = ctx.func.arg_metas[data_i]
+            FunctionDefTransformer._transform_func_arg(ctx, argument.name, argument.annotation, data)
 
+        # deal with dataclasses
         for v in ctx.func.orig_arguments:
             if dataclasses.is_dataclass(v.annotation):
                 ctx.create_variable(v.name, v.annotation)
@@ -308,7 +287,12 @@ class FunctionDefTransformer:
         if ctx.is_kernel:  # ti.kernel
             FunctionDefTransformer._transform_as_kernel(ctx, node, args)
 
-        else:  # ti.func
+        if ctx.only_parse_function_def:
+            return None
+
+        if not ctx.is_kernel:  # ti.func
+            assert ctx.argument_data is not None
+            assert ctx.func is not None
             if ctx.is_real_function:
                 FunctionDefTransformer._transform_as_kernel(ctx, node, args)
             else:

gstaichi/lang/field.py

@@ -9,7 +9,6 @@ from gstaichi.lang.util import (
     in_python_scope,
     python_scope,
     to_numpy_type,
-    to_paddle_type,
     to_pytorch_type,
 )
 
@@ -152,18 +151,6 @@ class Field:
         """
         raise NotImplementedError()
 
-    @python_scope
-    def to_paddle(self, place=None):
-        """Converts `self` to a paddle tensor.
-
-        Args:
-            place (paddle.CPUPlace()/CUDAPlace(n), optional): The desired place of returned tensor.
-
-        Returns:
-            paddle.Tensor: The result paddle tensor.
-        """
-        raise NotImplementedError()
-
     @python_scope
     def from_numpy(self, arr):
         """Loads all elements from a numpy array.
@@ -190,17 +177,6 @@ class Field:
         """
         self._from_external_arr(arr.contiguous())
 
-    @python_scope
-    def from_paddle(self, arr):
-        """Loads all elements from a paddle tensor.
-
-        The shape of the paddle tensor needs to be the same as `self`.
-
-        Args:
-            arr (paddle.Tensor): The source paddle tensor.
-        """
-        self.from_numpy(arr)
-
     @python_scope
     def copy_from(self, other):
         """Copies all elements from another field.
@@ -325,20 +301,6 @@ class ScalarField(Field):
         gstaichi.lang.runtime_ops.sync()
         return arr
 
-    @python_scope
-    def to_paddle(self, place=None):
-        """Converts this field to a `paddle.Tensor`."""
-        import paddle  # pylint: disable=C0415
-
-        # pylint: disable=E1101
-        # paddle.empty() doesn't support argument `place``
-        arr = paddle.to_tensor(paddle.zeros(self.shape, to_paddle_type(self.dtype)), place=place)
-        from gstaichi._kernels import tensor_to_ext_arr  # pylint: disable=C0415
-
-        tensor_to_ext_arr(self, arr)
-        gstaichi.lang.runtime_ops.sync()
-        return arr
-
     @python_scope
     def _from_external_arr(self, arr):
         if len(self.shape) != len(arr.shape):