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}/algorithms/_algorithms.py

@@ -1,18 +1,18 @@
 # type: ignore
 
-from taichi._kernels import (
+from gstaichi._kernels import (
     blit_from_field_to_field,
     scan_add_inclusive,
     sort_stage,
     uniform_add,
     warp_shfl_up_i32,
 )
-from taichi.lang.impl import current_cfg, field
-from taichi.lang.kernel_impl import data_oriented
-from taichi.lang.misc import cuda, vulkan
-from taichi.lang.runtime_ops import sync
-from taichi.lang.simt import subgroup
-from taichi.types.primitive_types import i32
+from gstaichi.lang.impl import current_cfg, field
+from gstaichi.lang.kernel_impl import data_oriented
+from gstaichi.lang.misc import cuda, vulkan
+from gstaichi.lang.runtime_ops import sync
+from gstaichi.lang.simt import subgroup
+from gstaichi.types.primitive_types import i32
 
 
 def parallel_sort(keys, values=None):

{taichi → gstaichi}/examples/minimal.py

@@ -1,4 +1,4 @@
-import taichi as ti
+import gstaichi as ti
 
 
 @ti.kernel

{taichi → gstaichi}/experimental.py

@@ -2,7 +2,7 @@
 
 import warnings
 
-from taichi.lang.kernel_impl import real_func as _real_func
+from gstaichi.lang.kernel_impl import real_func as _real_func
 
 
 def real_func(func):

gstaichi/lang/__init__.py

@@ -0,0 +1,50 @@
+# type: ignore
+
+from gstaichi.lang import impl, simt
+from gstaichi.lang._ndarray import *
+from gstaichi.lang._ndrange import ndrange
+from gstaichi.lang._texture import Texture
+from gstaichi.lang.argpack import *
+from gstaichi.lang.exception import *
+from gstaichi.lang.field import *
+from gstaichi.lang.impl import *
+from gstaichi.lang.kernel_impl import *
+from gstaichi.lang.matrix import *
+from gstaichi.lang.mesh import *
+from gstaichi.lang.misc import *  # pylint: disable=W0622
+from gstaichi.lang.ops import *  # pylint: disable=W0622
+from gstaichi.lang.runtime_ops import *
+from gstaichi.lang.snode import *
+from gstaichi.lang.source_builder import *
+from gstaichi.lang.struct import *
+from gstaichi.types.enums import DeviceCapability, Format, Layout
+
+__all__ = [
+    s
+    for s in dir()
+    if not s.startswith("_")
+    and s
+    not in [
+        "any_array",
+        "ast",
+        "common_ops",
+        "enums",
+        "exception",
+        "expr",
+        "impl",
+        "inspect",
+        "kernel_arguments",
+        "kernel_impl",
+        "matrix",
+        "mesh",
+        "misc",
+        "ops",
+        "platform",
+        "runtime_ops",
+        "shell",
+        "snode",
+        "source_builder",
+        "struct",
+        "util",
+    ]
+]

{taichi → gstaichi}/lang/_ndarray.py

@@ -1,19 +1,26 @@
 # type: ignore
 
+from typing import TYPE_CHECKING, Union
+
 import numpy as np
 
-from taichi._lib import core as _ti_core
-from taichi.lang import impl
-from taichi.lang.exception import TaichiIndexError
-from taichi.lang.util import cook_dtype, get_traceback, python_scope, to_numpy_type
-from taichi.types import primitive_types
-from taichi.types.enums import Layout
-from taichi.types.ndarray_type import NdarrayTypeMetadata
-from taichi.types.utils import is_real, is_signed
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang import impl
+from gstaichi.lang.exception import GsTaichiIndexError
+from gstaichi.lang.util import cook_dtype, get_traceback, python_scope, to_numpy_type
+from gstaichi.types import primitive_types
+from gstaichi.types.enums import Layout
+from gstaichi.types.ndarray_type import NdarrayTypeMetadata
+from gstaichi.types.utils import is_real, is_signed
+
+if TYPE_CHECKING:
+    from gstaichi.lang.matrix import MatrixNdarray, VectorNdarray
+
+    TensorNdarray = Union["ScalarNdarray", VectorNdarray, MatrixNdarray]
 
 
 class Ndarray:
-    """Taichi ndarray class.
+    """GsTaichi ndarray class.
 
     Args:
         dtype (DataType): Data type of each value.
@@ -27,7 +34,7 @@ class Ndarray:
         self.dtype = None
         self.arr = None
         self.layout = Layout.AOS
-        self.grad = None
+        self.grad: "TensorNdarray | None" = None
 
     def get_type(self):
         return NdarrayTypeMetadata(self.element_type, self.shape, self.grad is not None)
@@ -91,7 +98,7 @@ class Ndarray:
             numpy.ndarray: The result numpy array.
         """
         arr = np.zeros(shape=self.arr.total_shape(), dtype=to_numpy_type(self.dtype))
-        from taichi._kernels import ndarray_to_ext_arr  # pylint: disable=C0415
+        from gstaichi._kernels import ndarray_to_ext_arr  # pylint: disable=C0415
 
         ndarray_to_ext_arr(self, arr)
         impl.get_runtime().sync()
@@ -105,7 +112,7 @@ class Ndarray:
             numpy.ndarray: The result numpy array.
         """
         arr = np.zeros(shape=self.arr.total_shape(), dtype=to_numpy_type(self.dtype))
-        from taichi._kernels import ndarray_matrix_to_ext_arr  # pylint: disable=C0415
+        from gstaichi._kernels import ndarray_matrix_to_ext_arr  # pylint: disable=C0415
 
         layout_is_aos = 1
         ndarray_matrix_to_ext_arr(self, arr, layout_is_aos, as_vector)
@@ -126,7 +133,7 @@ class Ndarray:
         if not arr.flags.c_contiguous:
             arr = np.ascontiguousarray(arr)
 
-        from taichi._kernels import ext_arr_to_ndarray  # pylint: disable=C0415
+        from gstaichi._kernels import ext_arr_to_ndarray  # pylint: disable=C0415
 
         ext_arr_to_ndarray(arr, self)
         impl.get_runtime().sync()
@@ -147,7 +154,7 @@ class Ndarray:
         if not arr.flags.c_contiguous:
             arr = np.ascontiguousarray(arr)
 
-        from taichi._kernels import ext_arr_to_ndarray_matrix  # pylint: disable=C0415
+        from gstaichi._kernels import ext_arr_to_ndarray_matrix  # pylint: disable=C0415
 
         layout_is_aos = 1
         ext_arr_to_ndarray_matrix(arr, self, layout_is_aos, as_vector)
@@ -182,12 +189,12 @@ class Ndarray:
         """
         assert isinstance(other, Ndarray)
         assert tuple(self.arr.shape) == tuple(other.arr.shape)
-        from taichi._kernels import ndarray_to_ndarray  # pylint: disable=C0415
+        from gstaichi._kernels import ndarray_to_ndarray  # pylint: disable=C0415
 
         ndarray_to_ndarray(self, other)
         impl.get_runtime().sync()
 
-    def _set_grad(self, grad):
+    def _set_grad(self, grad: "TensorNdarray"):
         """Sets the gradient ndarray.
 
         Args:
@@ -218,7 +225,7 @@ class Ndarray:
         if not isinstance(key, (tuple, list)):
             key = (key,)
         if len(key) != len(self.arr.total_shape()):
-            raise TaichiIndexError(f"{len(self.arr.total_shape())}d ndarray indexed with {len(key)}d indices: {key}")
+            raise GsTaichiIndexError(f"{len(self.arr.total_shape())}d ndarray indexed with {len(key)}d indices: {key}")
         return key
 
     @python_scope
@@ -230,7 +237,7 @@ class Ndarray:
 
 
 class ScalarNdarray(Ndarray):
-    """Taichi ndarray with scalar elements.
+    """GsTaichi ndarray with scalar elements.
 
     Args:
         dtype (DataType): Data type of each value.
@@ -247,13 +254,10 @@ class ScalarNdarray(Ndarray):
         self.element_type = dtype
 
     def __del__(self):
-        if (
-            impl is not None
-            and impl.get_runtime is not None
-            and impl.get_runtime() is not None
-            and impl.get_runtime().prog is not None
-        ):
-            impl.get_runtime().prog.delete_ndarray(self.arr)
+        if impl is not None and impl.get_runtime is not None and impl.get_runtime() is not None:
+            prog = impl.get_runtime()._prog
+            if prog is not None:
+                prog.delete_ndarray(self.arr)
 
     @property
     def element_shape(self):
@@ -283,7 +287,7 @@ class ScalarNdarray(Ndarray):
         return ret_arr
 
     def _fill_by_kernel(self, val):
-        from taichi._kernels import fill_ndarray  # pylint: disable=C0415
+        from gstaichi._kernels import fill_ndarray  # pylint: disable=C0415
 
         fill_ndarray(self, val)
 

{taichi → gstaichi}/lang/_ndrange.py

@@ -5,11 +5,11 @@ from typing import Iterable
 
 import numpy as np
 
-from taichi.lang import ops
-from taichi.lang.exception import TaichiSyntaxError, TaichiTypeError
-from taichi.lang.expr import Expr
-from taichi.lang.matrix import Matrix
-from taichi.types.utils import is_integral
+from gstaichi.lang import ops
+from gstaichi.lang.exception import GsTaichiSyntaxError, GsTaichiTypeError
+from gstaichi.lang.expr import Expr
+from gstaichi.lang.matrix import Matrix
+from gstaichi.types.utils import is_integral
 
 
 class _Ndrange:
@@ -19,7 +19,7 @@ class _Ndrange:
             if not isinstance(arg, collections.abc.Sequence):
                 args[i] = (0, arg)
             if len(args[i]) != 2:
-                raise TaichiSyntaxError(
+                raise GsTaichiSyntaxError(
                     "Every argument of ndrange should be a scalar or a tuple/list like (begin, end)"
                 )
             args[i] = (args[i][0], ops.max(args[i][0], args[i][1]))
@@ -28,7 +28,7 @@ class _Ndrange:
                 if not isinstance(bound, (int, np.integer)) and not (
                     isinstance(bound, Expr) and is_integral(bound.ptr.get_rvalue_type())
                 ):
-                    raise TaichiTypeError(
+                    raise GsTaichiTypeError(
                         "Every argument of ndrange should be an integer scalar or a tuple/list of (int, int)"
                     )
         self.bounds = args
@@ -129,7 +129,7 @@ def ndrange(*args) -> Iterable:
 
         A typical usage of `ndrange` is when you want to loop over a tensor and process
         its entries in parallel. You should avoid writing nested `for` loops here since
-        only top level `for` loops are paralleled in taichi, instead you can use `ndrange`
+        only top level `for` loops are paralleled in gstaichi, instead you can use `ndrange`
         to hold all entries in one top level loop:
 
             >>> @ti.kernel

gstaichi/lang/_template_mapper.py

@@ -0,0 +1,199 @@
+import dataclasses
+import weakref
+from typing import Any, Union
+
+import gstaichi.lang
+import gstaichi.lang._ndarray
+import gstaichi.lang._texture
+import gstaichi.lang.expr
+import gstaichi.lang.snode
+from gstaichi._lib import core as _ti_core
+from gstaichi.lang.any_array import AnyArray
+from gstaichi.lang.argpack import ArgPack, ArgPackType
+from gstaichi.lang.exception import (
+    GsTaichiRuntimeTypeError,
+)
+from gstaichi.lang.kernel_arguments import KernelArgument
+from gstaichi.lang.matrix import MatrixType
+from gstaichi.lang.util import to_gstaichi_type
+from gstaichi.types import (
+    ndarray_type,
+    sparse_matrix_builder,
+    template,
+    texture_type,
+)
+
+AnnotationType = Union[
+    template,
+    ArgPackType,
+    "texture_type.TextureType",
+    "texture_type.RWTextureType",
+    ndarray_type.NdarrayType,
+    sparse_matrix_builder,
+    Any,
+]
+
+
+class GsTaichiCallableTemplateMapper:
+    """
+    This should probably be renamed to sometihng like FeatureMapper, or
+    FeatureExtractor, since:
+    - it's not specific to templates
+    - it extracts what are later called 'features', for example for ndarray this includes:
+        - element type
+        - number dimensions
+        - needs grad (or not)
+    - these are returned as a heterogeneous tuple, whose contents depends on the type
+    """
+
+    def __init__(self, arguments: list[KernelArgument], template_slot_locations: list[int]) -> None:
+        self.arguments: list[KernelArgument] = arguments
+        self.num_args: int = len(arguments)
+        self.template_slot_locations: list[int] = template_slot_locations
+        self.mapping: dict[tuple[Any, ...], int] = {}
+
+    @staticmethod
+    def extract_arg(arg, annotation: AnnotationType, arg_name: str) -> Any:
+        if annotation == template or isinstance(annotation, template):
+            if isinstance(arg, gstaichi.lang.snode.SNode):
+                return arg.ptr
+            if isinstance(arg, gstaichi.lang.expr.Expr):
+                return arg.ptr.get_underlying_ptr_address()
+            if isinstance(arg, _ti_core.ExprCxx):
+                return arg.get_underlying_ptr_address()
+            if isinstance(arg, tuple):
+                return tuple(GsTaichiCallableTemplateMapper.extract_arg(item, annotation, arg_name) for item in arg)
+            if isinstance(arg, gstaichi.lang._ndarray.Ndarray):
+                raise GsTaichiRuntimeTypeError(
+                    "Ndarray shouldn't be passed in via `ti.template()`, please annotate your kernel using `ti.types.ndarray(...)` instead"
+                )
+
+            if isinstance(arg, (list, tuple, dict, set)) or hasattr(arg, "_data_oriented"):
+                # [Composite arguments] Return weak reference to the object
+                # GsTaichi kernel will cache the extracted arguments, thus we can't simply return the original argument.
+                # Instead, a weak reference to the original value is returned to avoid memory leak.
+
+                # TODO(zhanlue): replacing "tuple(args)" with "hash of argument values"
+                # This can resolve the following issues:
+                # 1. Invalid weak-ref will leave a dead(dangling) entry in both caches: "self.mapping" and "self.compiled_functions"
+                # 2. Different argument instances with same type and same value, will get templatized into seperate kernels.
+                return weakref.ref(arg)
+
+            # [Primitive arguments] Return the value
+            return arg
+        if isinstance(annotation, ArgPackType):
+            if not isinstance(arg, ArgPack):
+                raise GsTaichiRuntimeTypeError(f"Argument {arg_name} must be a argument pack, got {type(arg)}")
+            return tuple(
+                GsTaichiCallableTemplateMapper.extract_arg(arg[name], dtype, arg_name)
+                for index, (name, dtype) in enumerate(annotation.members.items())
+            )
+        if dataclasses.is_dataclass(annotation):
+            _res_l = []
+            for field in dataclasses.fields(annotation):
+                field_value = getattr(arg, field.name)
+                arg_name = f"__ti_{arg_name}_{field.name}"
+                field_extracted = GsTaichiCallableTemplateMapper.extract_arg(field_value, field.type, arg_name)
+                _res_l.append(field_extracted)
+            return tuple(_res_l)
+        if isinstance(annotation, texture_type.TextureType):
+            if not isinstance(arg, gstaichi.lang._texture.Texture):
+                raise GsTaichiRuntimeTypeError(f"Argument {arg_name} must be a texture, got {type(arg)}")
+            if arg.num_dims != annotation.num_dimensions:
+                raise GsTaichiRuntimeTypeError(
+                    f"TextureType dimension mismatch for argument {arg_name}: expected {annotation.num_dimensions}, got {arg.num_dims}"
+                )
+            return (arg.num_dims,)
+        if isinstance(annotation, texture_type.RWTextureType):
+            if not isinstance(arg, gstaichi.lang._texture.Texture):
+                raise GsTaichiRuntimeTypeError(f"Argument {arg_name} must be a texture, got {type(arg)}")
+            if arg.num_dims != annotation.num_dimensions:
+                raise GsTaichiRuntimeTypeError(
+                    f"RWTextureType dimension mismatch for argument {arg_name}: expected {annotation.num_dimensions}, got {arg.num_dims}"
+                )
+            if arg.fmt != annotation.fmt:
+                raise GsTaichiRuntimeTypeError(
+                    f"RWTextureType format mismatch for argument {arg_name}: expected {annotation.fmt}, got {arg.fmt}"
+                )
+            # (penguinliong) '0' is the assumed LOD level. We currently don't
+            # support mip-mapping.
+            return arg.num_dims, arg.fmt, 0
+        if isinstance(annotation, ndarray_type.NdarrayType):
+            if isinstance(arg, gstaichi.lang._ndarray.Ndarray):
+                annotation.check_matched(arg.get_type(), arg_name)
+                needs_grad = (arg.grad is not None) if annotation.needs_grad is None else annotation.needs_grad
+                assert arg.shape is not None
+                return arg.element_type, len(arg.shape), needs_grad, annotation.boundary
+            if isinstance(arg, AnyArray):
+                ty = arg.get_type()
+                annotation.check_matched(arg.get_type(), arg_name)
+                return ty.element_type, len(arg.shape), ty.needs_grad, annotation.boundary
+            # external arrays
+            shape = getattr(arg, "shape", None)
+            if shape is None:
+                raise GsTaichiRuntimeTypeError(f"Invalid type for argument {arg_name}, got {arg}")
+            shape = tuple(shape)
+            element_shape: tuple[int, ...] = ()
+            dtype = to_gstaichi_type(arg.dtype)
+            if isinstance(annotation.dtype, MatrixType):
+                if annotation.ndim is not None:
+                    if len(shape) != annotation.dtype.ndim + annotation.ndim:
+                        raise ValueError(
+                            f"Invalid value for argument {arg_name} - required array has ndim={annotation.ndim} element_dim={annotation.dtype.ndim}, "
+                            f"array with {len(shape)} dimensions is provided"
+                        )
+                else:
+                    if len(shape) < annotation.dtype.ndim:
+                        raise ValueError(
+                            f"Invalid value for argument {arg_name} - required element_dim={annotation.dtype.ndim}, "
+                            f"array with {len(shape)} dimensions is provided"
+                        )
+                element_shape = shape[-annotation.dtype.ndim :]
+                anno_element_shape = annotation.dtype.get_shape()
+                if None not in anno_element_shape and element_shape != anno_element_shape:
+                    raise ValueError(
+                        f"Invalid value for argument {arg_name} - required element_shape={anno_element_shape}, "
+                        f"array with element shape of {element_shape} is provided"
+                    )
+            elif annotation.dtype is not None:
+                # User specified scalar dtype
+                if annotation.dtype != dtype:
+                    raise ValueError(
+                        f"Invalid value for argument {arg_name} - required array has dtype={annotation.dtype.to_string()}, "
+                        f"array with dtype={dtype.to_string()} is provided"
+                    )
+
+                if annotation.ndim is not None and len(shape) != annotation.ndim:
+                    raise ValueError(
+                        f"Invalid value for argument {arg_name} - required array has ndim={annotation.ndim}, "
+                        f"array with {len(shape)} dimensions is provided"
+                    )
+            needs_grad = (
+                getattr(arg, "requires_grad", False) if annotation.needs_grad is None else annotation.needs_grad
+            )
+            element_type = (
+                _ti_core.get_type_factory_instance().get_tensor_type(element_shape, dtype)
+                if len(element_shape) != 0
+                else arg.dtype
+            )
+            return element_type, len(shape) - len(element_shape), needs_grad, annotation.boundary
+        if isinstance(annotation, sparse_matrix_builder):
+            return arg.dtype
+        # Use '#' as a placeholder because other kinds of arguments are not involved in template instantiation
+        return "#"
+
+    def extract(self, args: tuple[Any, ...]) -> tuple[Any, ...]:
+        extracted: list[Any] = []
+        for arg, kernel_arg in zip(args, self.arguments):
+            extracted.append(self.extract_arg(arg, kernel_arg.annotation, kernel_arg.name))
+        return tuple(extracted)
+
+    def lookup(self, args: tuple[Any, ...]) -> tuple[int, tuple[Any, ...]]:
+        if len(args) != self.num_args:
+            raise TypeError(f"{self.num_args} argument(s) needed but {len(args)} provided.")
+
+        key = self.extract(args)
+        if key not in self.mapping:
+            count = len(self.mapping)
+            self.mapping[key] = count
+        return self.mapping[key], key

{taichi → gstaichi}/lang/_texture.py

@@ -2,13 +2,13 @@
 
 import numpy as np
 
-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.matrix import Matrix
-from taichi.lang.util import taichi_scope
-from taichi.types import vector
-from taichi.types.primitive_types import f32
+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.matrix import Matrix
+from gstaichi.lang.util import gstaichi_scope
+from gstaichi.types import vector
+from gstaichi.types.primitive_types import f32
 
 
 def _get_entries(mat):
@@ -22,7 +22,7 @@ class TextureSampler:
         self.ptr_expr = ptr_expr
         self.num_dims = num_dims
 
-    @taichi_scope
+    @gstaichi_scope
     def sample_lod(self, uv, lod):
         ast_builder = impl.get_runtime().compiling_callable.ast_builder()
         dbg_info = _ti_core.DebugInfo(impl.get_runtime().get_current_src_info())
@@ -34,7 +34,7 @@ class TextureSampler:
         a = impl.call_internal("composite_extract_3", v, with_runtime_context=False)
         return vector(4, f32)([r, g, b, a])
 
-    @taichi_scope
+    @gstaichi_scope
     def fetch(self, index, lod):
         ast_builder = impl.get_runtime().compiling_callable.ast_builder()
         dbg_info = _ti_core.DebugInfo(impl.get_runtime().get_current_src_info())
@@ -49,11 +49,11 @@ class TextureSampler:
 
 class RWTextureAccessor:
     def __init__(self, ptr_expr, num_dims) -> None:
-        # taichi_python.TexturePtrExpression.
+        # gstaichi_python.TexturePtrExpression.
         self.ptr_expr = ptr_expr
         self.num_dims = num_dims
 
-    @taichi_scope
+    @gstaichi_scope
     def load(self, index):
         ast_builder = impl.get_runtime().compiling_callable.ast_builder()
         dbg_info = _ti_core.DebugInfo(impl.get_runtime().get_current_src_info())
@@ -65,7 +65,7 @@ class RWTextureAccessor:
         a = impl.call_internal("composite_extract_3", v, with_runtime_context=False)
         return vector(4, f32)([r, g, b, a])
 
-    @taichi_scope
+    @gstaichi_scope
     def store(self, index, value):
         ast_builder = impl.get_runtime().compiling_callable.ast_builder()
         dbg_info = _ti_core.DebugInfo(impl.get_runtime().get_current_src_info())
@@ -75,7 +75,7 @@ class RWTextureAccessor:
         )
 
     @property
-    @taichi_scope
+    @gstaichi_scope
     def shape(self):
         """A list containing sizes for each dimension. Note that element shape will be excluded.
 
@@ -87,18 +87,18 @@ class RWTextureAccessor:
         ret = [Expr(_ti_core.get_external_tensor_shape_along_axis(self.ptr_expr, i, dbg_info)) for i in range(dim)]
         return ret
 
-    @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_expr
 
 
 class Texture:
-    """Taichi Texture class.
+    """GsTaichi Texture class.
 
     Args:
         fmt (ti.Format): Color format of the texture.
@@ -148,7 +148,7 @@ class Texture:
         # Don't use transpose method since its enums are too new
         image = image.rotate(90, expand=True)
         arr = np.asarray(image)
-        from taichi._kernels import (  # pylint: disable=import-outside-toplevel
+        from gstaichi._kernels import (  # pylint: disable=import-outside-toplevel
             load_texture_from_numpy,
         )
 
@@ -164,7 +164,7 @@ class Texture:
         from PIL import Image  # pylint: disable=import-outside-toplevel
 
         res = np.zeros(self.shape + (3,), np.uint8)
-        from taichi._kernels import (  # pylint: disable=import-outside-toplevel
+        from gstaichi._kernels import (  # pylint: disable=import-outside-toplevel
             save_texture_to_numpy,
         )
 

{taichi → gstaichi}/lang/_wrap_inspect.py

@@ -1,19 +1,19 @@
 # type: ignore
 
-# Taichi's custom inspect module.
-# This module is used by Taichi's ast transformer to parse the source code.
+# GsTaichi's custom inspect module.
+# This module is used by GsTaichi's ast transformer to parse the source code.
 # Currently this module is aimed for working in the following modes:
 # 1. Usual Python/IPython mode, e.g. python script.py
 #    In this case we mainly rely on the built-in `inspect` module, except
 #    we need some hacks when we are in IPython mode and there is a cell magic.
-# 2. Blender's scripting mode, e.g. Users write Taichi code in the scripting
+# 2. Blender's scripting mode, e.g. Users write GsTaichi code in the scripting
 #    window in Blender and press the run button. In this case we need to
 #    retrieve the source using Blender's `bpy.data.texts` and write it to a temp
 #    file so that the inspect module can parse.
 # 3. The interactive shell mode, e.g. Users directly type their code in the
 #    interactive shell. In this case we use `dill` to get the source.
 #
-# NB: Running Taichi in other modes are likely not supported.
+# NB: Running GsTaichi in other modes are likely not supported.
 
 import atexit
 import inspect
@@ -137,7 +137,7 @@ def _Python_IPython_findsource(obj):
                 pass
         raise IOError(
             f"Cannot find source code for Object: {obj}, it's likely \
-you are not running Taichi from command line or IPython."
+you are not running GsTaichi from command line or IPython."
         )
 
 
@@ -158,9 +158,9 @@ def _custom_findsource(obj):
             except:
                 raise IOError(
                     f"Cannot find source code for Object: {obj}, this \
-is possibly because of you are running Taichi in an environment that Taichi's own \
+is possibly because of you are running GsTaichi in an environment that GsTaichi's own \
 inspect module cannot find the source. Please report an issue to help us fix: \
-https://github.com/taichi-dev/taichi/issues"
+https://github.com/taichi-dev/gstaichi/issues"
                 )