gstaichi 0.1.23.dev0__cp310-cp310-win_amd64.whl → 1.0.1__cp310-cp310-win_amd64.whl

{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