gstaichi 0.1.20.dev0__cp310-cp310-macosx_15_0_arm64.whl → 0.1.25.dev0__cp310-cp310-macosx_15_0_arm64.whl

{taichi → gstaichi}/lang/any_array.py

@@ -1,18 +1,18 @@
 # type: ignore
 
-from taichi._lib import core as _ti_core
-from taichi.lang import impl
-from taichi.lang.expr import Expr, make_expr_group
-from taichi.lang.util import taichi_scope
-from taichi.types.enums import Layout
-from taichi.types.ndarray_type import NdarrayTypeMetadata
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang import impl
+from gstaichi.lang.expr import Expr, make_expr_group
+from gstaichi.lang.util import gstaichi_scope
+from gstaichi.types.enums import Layout
+from gstaichi.types.ndarray_type import NdarrayTypeMetadata
 
 
 class AnyArray:
     """Class for arbitrary arrays in Python AST.
 
     Args:
-        ptr (taichi_python.Expr): A taichi_python.Expr wrapping a taichi_python.ExternalTensorExpression.
+        ptr (gstaichi_python.Expr): A gstaichi_python.Expr wrapping a gstaichi_python.ExternalTensorExpression.
         element_shape (Tuple[Int]): () if scalar elements (default), (n) if vector elements, and (n, m) if matrix elements.
         layout (Layout): Memory layout.
     """
@@ -39,13 +39,13 @@ class AnyArray:
         )  # AnyArray can take any shape
 
     @property
-    @taichi_scope
+    @gstaichi_scope
     def grad(self):
         """Returns the gradient of this array."""
         return AnyArray(_ti_core.make_external_tensor_grad_expr(self.ptr))
 
     @property
-    @taichi_scope
+    @gstaichi_scope
     def shape(self):
         """A list containing sizes for each dimension. Note that element shape will be excluded.
 
@@ -56,12 +56,12 @@ class AnyArray:
         dbg_info = _ti_core.DebugInfo(impl.get_runtime().get_current_src_info())
         return [Expr(_ti_core.get_external_tensor_shape_along_axis(self.ptr, i, dbg_info)) for i in range(dim)]
 
-    @taichi_scope
+    @gstaichi_scope
     def _loop_range(self):
-        """Gets the corresponding taichi_python.Expr to serve as loop range.
+        """Gets the corresponding gstaichi_python.Expr to serve as loop range.
 
         Returns:
-            taichi_python.Expr: See above.
+            gstaichi_python.Expr: See above.
         """
         return self.ptr
 
@@ -78,7 +78,7 @@ class AnyArrayAccess:
         self.arr = arr
         self.indices_first = indices_first
 
-    @taichi_scope
+    @gstaichi_scope
     def subscript(self, i, j):
         ast_builder = impl.get_runtime().compiling_callable.ast_builder()
 

{taichi → gstaichi}/lang/argpack.py

@@ -2,24 +2,24 @@
 
 import numpy as np
 
-import taichi.lang
-from taichi._lib import core as _ti_core
-from taichi.lang import impl, ops
-from taichi.lang.exception import (
-    TaichiRuntimeTypeError,
-    TaichiSyntaxError,
+import gstaichi.lang
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang import impl, ops
+from gstaichi.lang.exception import (
+    GsTaichiRuntimeTypeError,
+    GsTaichiSyntaxError,
 )
-from taichi.lang.matrix import Matrix, MatrixType
-from taichi.lang.struct import Struct, StructType
-from taichi.lang.util import cook_dtype, in_python_scope, python_scope
-from taichi.types import (
+from gstaichi.lang.matrix import Matrix, MatrixType
+from gstaichi.lang.struct import Struct, StructType
+from gstaichi.lang.util import cook_dtype, in_python_scope, python_scope
+from gstaichi.types import (
     ndarray_type,
     primitive_types,
     sparse_matrix_builder,
     texture_type,
 )
-from taichi.types.compound_types import CompoundType
-from taichi.types.utils import is_signed
+from gstaichi.types.compound_types import CompoundType
+from gstaichi.types.utils import is_signed
 
 
 class ArgPack:
@@ -27,7 +27,7 @@ class ArgPack:
 
     The `ArgPack` operates as a dictionary-like data pack, storing members as (key, value) pairs. Members stored can
     range from scalars and matrices to other dictionary-like structures. Distinguished from structs, `ArgPack` can
-    accommodate buffer types such as `NdarrayType` and `TextureType` from Taichi. However, unlike `ti.Struct` which
+    accommodate buffer types such as `NdarrayType` and `TextureType` from GsTaichi. However, unlike `ti.Struct` which
     serves as a data container, `ArgPack` functions as a reference container. It's important to note that `ArgPack`
     cannot be nested within other types except for another `ArgPack`, and can only be utilized as kernel parameters.
 
@@ -60,11 +60,11 @@ class ArgPack:
         elif len(args) == 0:
             self.__entries = kwargs
         else:
-            raise TaichiSyntaxError(
+            raise GsTaichiSyntaxError(
                 "Custom argument packs need to be initialized using either dictionary or keyword arguments"
             )
         if annotations.keys() != self.__entries.keys():
-            raise TaichiSyntaxError("ArgPack annotations keys not equals to entries keys.")
+            raise GsTaichiSyntaxError("ArgPack annotations keys not equals to entries keys.")
         self.__annotations = annotations
         for k, v in self.__entries.items():
             self.__entries[k] = v if in_python_scope() else impl.expr_init(v)
@@ -198,28 +198,28 @@ class ArgPack:
     def _write_to_device(self, needed, provided, v, index):
         if isinstance(needed, ArgPackType):
             if not isinstance(v, ArgPack):
-                raise TaichiRuntimeTypeError.get(index, str(needed), str(provided))
+                raise GsTaichiRuntimeTypeError.get(index, str(needed), str(provided))
             self.__argpack.set_arg_nested_argpack(index, v.__argpack)
         else:
             # Note: do not use sth like "needed == f32". That would be slow.
             if id(needed) in primitive_types.real_type_ids:
                 if not isinstance(v, (float, int, np.floating, np.integer)):
-                    raise TaichiRuntimeTypeError.get(index, needed.to_string(), provided)
+                    raise GsTaichiRuntimeTypeError.get(index, needed.to_string(), provided)
                 self.__argpack.set_arg_float((index,), float(v))
             elif id(needed) in primitive_types.integer_type_ids:
                 if not isinstance(v, (int, np.integer)):
-                    raise TaichiRuntimeTypeError.get(index, needed.to_string(), provided)
+                    raise GsTaichiRuntimeTypeError.get(index, needed.to_string(), provided)
                 if is_signed(cook_dtype(needed)):
                     self.__argpack.set_arg_int((index,), int(v))
                 else:
                     self.__argpack.set_arg_uint((index,), int(v))
             elif isinstance(needed, sparse_matrix_builder):
                 pass
-            elif isinstance(needed, ndarray_type.NdarrayType) and isinstance(v, taichi.lang._ndarray.Ndarray):
+            elif isinstance(needed, ndarray_type.NdarrayType) and isinstance(v, gstaichi.lang._ndarray.Ndarray):
                 pass
-            elif isinstance(needed, texture_type.TextureType) and isinstance(v, taichi.lang._texture.Texture):
+            elif isinstance(needed, texture_type.TextureType) and isinstance(v, gstaichi.lang._texture.Texture):
                 pass
-            elif isinstance(needed, texture_type.RWTextureType) and isinstance(v, taichi.lang._texture.Texture):
+            elif isinstance(needed, texture_type.RWTextureType) and isinstance(v, gstaichi.lang._texture.Texture):
                 pass
             elif isinstance(needed, ndarray_type.NdarrayType):
                 pass
@@ -228,14 +228,14 @@ class ArgPack:
 
                     def cast_func(x):
                         if not isinstance(x, (int, float, np.integer, np.floating)):
-                            raise TaichiRuntimeTypeError.get(index, needed.dtype.to_string(), type(x))
+                            raise GsTaichiRuntimeTypeError.get(index, needed.dtype.to_string(), type(x))
                         return float(x)
 
                 elif needed.dtype in primitive_types.integer_types:
 
                     def cast_func(x):
                         if not isinstance(x, (int, np.integer)):
-                            raise TaichiRuntimeTypeError.get(index, needed.dtype.to_string(), type(x))
+                            raise GsTaichiRuntimeTypeError.get(index, needed.dtype.to_string(), type(x))
                         return int(x)
 
                 else:
@@ -249,7 +249,7 @@ class ArgPack:
                 needed.set_argpack_struct_args(v, self.__argpack, (index,))
             elif isinstance(needed, StructType):
                 if not isinstance(v, needed):
-                    raise TaichiRuntimeTypeError.get(index, str(needed), provided)
+                    raise GsTaichiRuntimeTypeError.get(index, str(needed), provided)
                 needed.set_argpack_struct_args(v, self.__argpack, (index,))
             else:
                 raise ValueError(f"Argument type mismatch. Expecting {needed}, got {type(v)}.")
@@ -270,11 +270,11 @@ class _IntermediateArgPack(ArgPack):
         elif len(args) == 0:
             self._ArgPack__entries = kwargs
         else:
-            raise TaichiSyntaxError(
+            raise GsTaichiSyntaxError(
                 "Custom argument packs need to be initialized using either dictionary or keyword arguments"
             )
         if annotations.keys() != self._ArgPack__entries.keys():
-            raise TaichiSyntaxError("ArgPack annotations keys not equals to entries keys.")
+            raise GsTaichiSyntaxError("ArgPack annotations keys not equals to entries keys.")
         self._ArgPack__annotations = annotations
         self._register_members()
         self._ArgPack__dtype = dtype
@@ -296,7 +296,7 @@ class ArgPackType(CompoundType):
                 self.members[k] = dtype
                 elements.append(
                     [
-                        _ti_core.DataType(
+                        _ti_core.DataTypeCxx(
                             _ti_core.get_type_factory_instance().get_struct_type_for_argpack_ptr(dtype.dtype)
                         ),
                         k,
@@ -366,7 +366,7 @@ class ArgPackType(CompoundType):
     def cast(self, pack):
         # sanity check members
         if self.members.keys() != pack._ArgPack__entries.keys():
-            raise TaichiSyntaxError("Incompatible arguments for custom argument pack members!")
+            raise GsTaichiSyntaxError("Incompatible arguments for custom argument pack members!")
         entries = {}
         for k, dtype in self.members.items():
             if isinstance(dtype, MatrixType):
@@ -392,7 +392,7 @@ class ArgPackType(CompoundType):
         pack = ArgPack(self.members, self.dtype, entries)
         return pack
 
-    def from_taichi_object(self, arg_load_dict: dict):
+    def from_gstaichi_object(self, arg_load_dict: dict):
         d = {}
         items = self.members.items()
         for index, pair in enumerate(items):

gstaichi/lang/ast/__init__.py

@@ -0,0 +1,5 @@
+# type: ignore
+
+from gstaichi.lang.ast.ast_transformer_utils import ASTTransformerContext
+from gstaichi.lang.ast.checkers import KernelSimplicityASTChecker
+from gstaichi.lang.ast.transform import transform_tree