gstaichi 1.0.1__cp311-cp311-win_amd64.whl → 2.1.0__cp311-cp311-win_amd64.whl

gstaichi/lang/matrix.py

@@ -27,7 +27,6 @@ from gstaichi.lang.util import (
     in_python_scope,
     python_scope,
     to_numpy_type,
-    to_paddle_type,
     to_pytorch_type,
     warning,
 )
@@ -1301,33 +1300,6 @@ class MatrixField(Field):
         runtime_ops.sync()
         return arr
 
-    def to_paddle(self, place=None, keep_dims=False):
-        """Converts the field instance to a Paddle tensor.
-
-        Args:
-            place (paddle.CPUPlace()/CUDAPlace(n), optional): The desired place of returned tensor.
-            keep_dims (bool, optional): Whether to keep the dimension after conversion.
-                See :meth:`~gstaichi.lang.field.MatrixField.to_numpy` for more detailed explanation.
-
-        Returns:
-            paddle.Tensor: The result paddle tensor.
-        """
-        import paddle  # pylint: disable=C0415
-
-        as_vector = self.m == 1 and not keep_dims and self.ndim == 1
-        shape_ext = (self.n,) if as_vector else (self.n, self.m)
-        # pylint: disable=E1101
-        # paddle.empty() doesn't support argument `place``
-        arr = paddle.to_tensor(
-            paddle.empty(self.shape + shape_ext, to_paddle_type(self.dtype)),
-            place=place,
-        )
-        from gstaichi._kernels import matrix_to_ext_arr  # pylint: disable=C0415
-
-        matrix_to_ext_arr(self, arr, as_vector)
-        runtime_ops.sync()
-        return arr
-
     @python_scope
     def _from_external_arr(self, arr):
         if len(arr.shape) == len(self.shape) + 1:
@@ -1500,24 +1472,6 @@ class MatrixType(CompoundType):
                 for j in range(self.m):
                     set_arg_func(ret_index + (i * self.m + j,), mat[i, j])
 
-    def set_argpack_struct_args(self, mat, argpack, ret_index=()):
-        if self.dtype in primitive_types.integer_types:
-            if is_signed(cook_dtype(self.dtype)):
-                set_arg_func = argpack.set_arg_int
-            else:
-                set_arg_func = argpack.set_arg_uint
-        elif self.dtype in primitive_types.real_types:
-            set_arg_func = argpack.set_arg_float
-        else:
-            raise GsTaichiRuntimeTypeError(f"Invalid return type on index={ret_index}")
-        if self.ndim == 1:
-            for i in range(self.n):
-                set_arg_func(ret_index + (i,), mat[i])
-        else:
-            for i in range(self.n):
-                for j in range(self.m):
-                    set_arg_func(ret_index + (i * self.m + j,), mat[i, j])
-
     def _instantiate_in_python_scope(self, entries):
         entries = [[entries[k * self.m + i] for i in range(self.m)] for k in range(self.n)]
         return Matrix(

gstaichi/lang/struct.py

@@ -528,17 +528,6 @@ class StructField(Field):
         for k, v in self._items:
             v.from_torch(array_dict[k])
 
-    @python_scope
-    def from_paddle(self, array_dict):
-        """Copies the data from a set of `paddle.Tensor` into this field.
-
-        The argument `array_dict` must be a dictionay-like object, it
-        contains all the keys in this field and the copying process
-        between corresponding items can be performed.
-        """
-        for k, v in self._items:
-            v.from_paddle(array_dict[k])
-
     @python_scope
     def to_numpy(self):
         """Converts the Struct field instance to a dictionary of NumPy arrays.
@@ -566,22 +555,6 @@ class StructField(Field):
         """
         return {k: v.to_torch(device=device) for k, v in self._items}
 
-    @python_scope
-    def to_paddle(self, place=None):
-        """Converts the Struct field instance to a dictionary of Paddle tensors.
-
-        The dictionary may be nested when converting nested structs.
-
-        Args:
-            place (paddle.CPUPlace()/CUDAPlace(n), optional): The
-                desired place of returned tensor.
-
-        Returns:
-            Dict[str, Union[paddle.Tensor, Dict]]: The result
-                Paddle tensor.
-        """
-        return {k: v.to_paddle(place=place) for k, v in self._items}
-
     @python_scope
     def __setitem__(self, indices, element):
         self._initialize_host_accessors()
@@ -742,24 +715,6 @@ class StructType(CompoundType):
                 else:
                     raise GsTaichiRuntimeTypeError(f"Invalid argument type on index={ret_index + (index, )}")
 
-    def set_argpack_struct_args(self, struct, argpack, ret_index=()):
-        # TODO: move this to class Struct after we add dtype to Struct
-        items = self.members.items()
-        for index, pair in enumerate(items):
-            name, dtype = pair
-            if isinstance(dtype, CompoundType):
-                dtype.set_kernel_struct_args(struct[name], argpack, ret_index + (index,))
-            else:
-                if dtype in primitive_types.integer_types:
-                    if is_signed(cook_dtype(dtype)):
-                        argpack.set_arg_int(ret_index + (index,), struct[name])
-                    else:
-                        argpack.set_arg_uint(ret_index + (index,), struct[name])
-                elif dtype in primitive_types.real_types:
-                    argpack.set_arg_float(ret_index + (index,), struct[name])
-                else:
-                    raise GsTaichiRuntimeTypeError(f"Invalid argument type on index={ret_index + (index, )}")
-
     def cast(self, struct):
         # sanity check members
         if self.members.keys() != struct._Struct__entries.keys():

gstaichi/lang/util.py

@@ -1,9 +1,8 @@
-# type: ignore
-
 import functools
 import os
 import traceback
 import warnings
+from typing import Any
 
 import numpy as np
 from colorama import Fore, Style
@@ -11,6 +10,7 @@ from colorama import Fore, Style
 from gstaichi._lib import core as _ti_core
 from gstaichi._logging import is_logging_effective
 from gstaichi.lang import impl
+from gstaichi.types import Template
 from gstaichi.types.primitive_types import (
     f16,
     f32,
@@ -46,24 +46,6 @@ def has_pytorch():
     return _has_pytorch
 
 
-def has_paddle():
-    """Whether has paddle in the current Python environment.
-
-    Returns:
-        bool: True if has paddle else False.
-    """
-    _has_paddle = False
-    _env_paddle = os.environ.get("TI_ENABLE_PADDLE", "1")
-    if not _env_paddle or int(_env_paddle):
-        try:
-            import paddle  # pylint: disable=C0415
-
-            _has_paddle = True
-        except:
-            pass
-    return _has_paddle
-
-
 def get_clangpp():
     from distutils.spawn import find_executable  # pylint: disable=C0415
 
@@ -183,43 +165,8 @@ def to_pytorch_type(dt):
     raise RuntimeError(f"PyTorch doesn't support {dt.to_string()} data type.")
 
 
-def to_paddle_type(dt):
-    """Convert gstaichi data type to its counterpart in paddle.
-
-    Args:
-        dt (DataType): The desired data type to convert.
-
-    Returns:
-        DataType: The counterpart data type in paddle.
-
-    """
-    import paddle  # pylint: disable=C0415
-
-    if dt == f32:
-        return paddle.float32
-    if dt == f64:
-        return paddle.float64
-    if dt == i32:
-        return paddle.int32
-    if dt == i64:
-        return paddle.int64
-    if dt == i8:
-        return paddle.int8
-    if dt == i16:
-        return paddle.int16
-    if dt == u1:
-        return paddle.bool
-    if dt == u8:
-        return paddle.uint8
-    if dt == f16:
-        return paddle.float16
-    if dt in (u16, u32, u64):
-        raise RuntimeError(f"Paddle doesn't support {dt.to_string()} data type.")
-    assert False
-
-
 def to_gstaichi_type(dt):
-    """Convert numpy or torch or paddle data type to its counterpart in gstaichi.
+    """Convert numpy or torch data type to its counterpart in gstaichi.
 
     Args:
         dt (DataType): The desired data type to convert.
@@ -289,30 +236,6 @@ def to_gstaichi_type(dt):
 
         raise RuntimeError(f"PyTorch doesn't support {dt.to_string()} data type before version 2.3.0.")
 
-    if has_paddle():
-        import paddle  # pylint: disable=C0415
-
-        if dt == paddle.float32:
-            return f32
-        if dt == paddle.float64:
-            return f64
-        if dt == paddle.int32:
-            return i32
-        if dt == paddle.int64:
-            return i64
-        if dt == paddle.int8:
-            return i8
-        if dt == paddle.int16:
-            return i16
-        if dt == paddle.bool:
-            return u1
-        if dt == paddle.uint8:
-            return u8
-        if dt == paddle.float16:
-            return f16
-        if dt in (u16, u32, u64):
-            raise RuntimeError(f"Paddle doesn't support {dt.to_string()} data type.")
-
     raise AssertionError(f"Unknown type {dt}")
 
 
@@ -378,4 +301,12 @@ def get_traceback(stacklevel=1):
     return "".join(traceback.format_list(s))
 
 
+def is_data_oriented(obj: Any) -> bool:
+    return getattr(obj, "_data_oriented", False)
+
+
+def is_ti_template(annotation: Any) -> bool:
+    return annotation == Template or isinstance(annotation, Template)
+
+
 __all__ = []

gstaichi/types/annotations.py

@@ -1,7 +1,9 @@
-# type: ignore
+from typing import Any, Generic, TypeVar
 
+T = TypeVar("T")
 
-class Template:
+
+class Template(Generic[T]):
     """Type annotation for template kernel parameter.
     Useful for passing parameters to kernels by reference.
 
@@ -30,9 +32,12 @@ class Template:
         >>> test_template(a)  # will print 2
     """
 
-    def __init__(self, tensor=None, dim=None):
-        self.tensor = tensor
-        self.dim = dim
+    def __init__(self, element_type: type[T] = object, ndim: int | None = None):
+        self.element_type = element_type
+        self.ndim = ndim
+
+    def __getitem__(self, i: Any) -> T:
+        raise NotImplemented
 
 
 template = Template

gstaichi/types/compound_types.py

@@ -68,23 +68,4 @@ def struct(**kwargs):
     return gstaichi.lang.struct.StructType(**kwargs)
 
 
-def argpack(**kwargs):
-    """Creates an argument pack type with given members.
-
-    Args:
-        kwargs (dict): a dictionary contains the names and types of the
-            argument pack members.
-
-    Returns:
-        A argument pack type.
-
-    Example::
-
-        >>> vec3 = ti.types.vector(3, ti.f32)
-        >>> sphere = ti.types.argpack(center=vec3, radius=float)
-        >>> s = sphere(center=vec3([0., 0., 0.]), radius=1.0)
-    """
-    return gstaichi.lang.argpack.ArgPackType(**kwargs)
-
-
-__all__ = ["matrix", "vector", "struct", "argpack"]
+__all__ = ["matrix", "vector", "struct"]

gstaichi/types/ndarray_type.py

@@ -1,4 +1,4 @@
-# type: ignore
+from typing import Any
 
 from gstaichi.types.compound_types import CompoundType, matrix, vector
 from gstaichi.types.enums import Layout, to_boundary_enum
@@ -32,7 +32,8 @@ def _make_matrix_dtype_from_element_shape(element_dim, element_shape, primitive_
         # Check dim consistency. The matrix dtype will be cooked later.
         if element_shape is not None and len(element_shape) != element_dim:
             raise ValueError(
-                f"Both element_shape and element_dim are specified, but shape doesn't match specified dim: {len(element_shape)}!={element_dim}"
+                f"Both element_shape and element_dim are specified, but shape doesn't match specified dim: "
+                f"{len(element_shape)}!={element_dim}"
             )
         mat_dtype = vector(None, primitive_dtype) if element_dim == 1 else matrix(None, None, primitive_dtype)
     elif element_shape is not None:
@@ -50,14 +51,24 @@ class NdarrayType:
     """Type annotation for arbitrary arrays, including external arrays (numpy ndarrays and torch tensors) and GsTaichi ndarrays.
 
     For external arrays, we treat it as a GsTaichi data container with Scalar, Vector or Matrix elements.
-    For GsTaichi vector/matrix ndarrays, we will automatically identify element dimension and their corresponding axis by the dimension of datatype, say scalars, matrices or vectors.
-    For example, given type annotation `ti.types.ndarray(dtype=ti.math.vec3)`, a numpy array `np.zeros(10, 10, 3)` will be recognized as a 10x10 matrix composed of vec3 elements.
+    For GsTaichi vector/matrix ndarrays, we will automatically identify element dimension and their corresponding axis by the
+    dimension of datatype, say scalars, matrices or vectors.
+    For example, given type annotation `ti.types.ndarray(dtype=ti.math.vec3)`, a numpy array `np.zeros(10, 10, 3)` will be
+    recognized as a 10x10 matrix composed of vec3 elements.
 
     Args:
         dtype (Union[PrimitiveType, VectorType, MatrixType, NoneType], optional): None if not speicified.
-        ndim (Union[Int, NoneType]): None if not specified, number of field dimensions. This argument is ignored for external arrays for now.
-        element_dim (Union[Int, NoneType], optional): None if not specified (will be treated as 0 for external arrays), 0 if scalar elements, 1 if vector elements, and 2 if matrix elements.
-        element_shape (Union[Tuple[Int], NoneType]): None if not specified, shapes of each element. For example, element_shape must be 1d for vector and 2d tuple for matrix. This argument is ignored for external arrays for now.
+        ndim (Union[Int, NoneType]): None if not specified, number of field dimensions. This argument is ignored for externa
+        arrays for now.
+        element_dim (Union[Int, NoneType], optional):
+          None if not specified (will be treated as 0 for external arrays),
+          0 if scalar elements,
+          1 if vector elements, and
+          2 if matrix elements.
+        element_shape (Union[Tuple[Int], NoneType]):
+          None if not specified, shapes of each element.
+          For example, element_shape must be 1d for vector and 2d tuple for matrix.
+          This argument is ignored for external arrays for now.
     """
 
     def __init__(
@@ -93,9 +104,10 @@ class NdarrayType:
 
         # Check dtype match
         if isinstance(self.dtype, CompoundType):
-            if not self.dtype.check_matched(ndarray_type.element_type):
+            if not self.dtype.check_matched(ndarray_type.element_type):  # type: ignore
                 raise ValueError(
-                    f"Invalid value for argument {arg_name} - required element type: {self.dtype.to_string()}, but {ndarray_type.element_type.to_string()} is provided"
+                    f"Invalid value for argument {arg_name} - required element type: {self.dtype.to_string()}, "  # type: ignore
+                    f"but {ndarray_type.element_type.to_string()} is provided"
                 )
         else:
             if self.dtype is not None:
@@ -110,14 +122,16 @@ class NdarrayType:
         # Check ndim match
         if self.ndim is not None and ndarray_type.shape is not None and self.ndim != len(ndarray_type.shape):
             raise ValueError(
-                f"Invalid value for argument {arg_name} - required ndim={self.ndim}, but {len(ndarray_type.shape)}d ndarray with shape {ndarray_type.shape} is provided"
+                f"Invalid value for argument {arg_name} - required ndim={self.ndim}, but {len(ndarray_type.shape)}d "
+                f"ndarray with shape {ndarray_type.shape} is provided"
             )
 
         # Check needs_grad
         if self.needs_grad is not None and self.needs_grad > ndarray_type.needs_grad:
             # It's okay to pass a needs_grad=True ndarray at runtime to a need_grad=False arg but not vice versa.
             raise ValueError(
-                f"Invalid value for argument {arg_name} - required needs_grad={self.needs_grad}, but {ndarray_type.needs_grad} is provided"
+                f"Invalid value for argument {arg_name} - required needs_grad={self.needs_grad}, but "
+                f"{ndarray_type.needs_grad} is provided"
             )
 
     def __repr__(self):
@@ -126,6 +140,14 @@ class NdarrayType:
     def __str__(self):
         return self.__repr__()
 
+    def __getitem__(self, i: Any) -> Any:
+        # needed for pyright
+        raise NotImplemented
+
+    def __setitem__(self, i: Any, v: Any) -> None:
+        # needed for pyright
+        raise NotImplemented
+
 
 ndarray = NdarrayType
 NDArray = NdarrayType

gstaichi/types/utils.py

@@ -1,5 +1,3 @@
-# type: ignore
-
 from gstaichi._lib import core as ti_python_core
 
 is_signed = ti_python_core.is_signed