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

{taichi → gstaichi}/_lib/utils.py

@@ -45,11 +45,11 @@ def import_ti_python_core():
         pyddir = os.path.dirname(os.path.realpath(__file__))
         os.environ["PATH"] += os.pathsep + pyddir
     try:
-        from taichi._lib.core import taichi_python as core  # pylint: disable=C0415
+        from gstaichi._lib.core import gstaichi_python as core  # pylint: disable=C0415
     except Exception as e:
         if isinstance(e, ImportError):
             print(
-                Fore.YELLOW + "Share object taichi_python import failed, "
+                Fore.YELLOW + "Share object gstaichi_python import failed, "
                 "check this page for possible solutions:\n"
                 "https://docs.taichi-lang.org/docs/install" + Fore.RESET
             )
@@ -89,7 +89,7 @@ package_root = os.path.join(os.path.dirname(os.path.dirname(os.path.realpath(__f
 
 def get_core_shared_object():
     directory = os.path.join(package_root, "_lib")
-    return os.path.join(directory, "libtaichi_python.so")
+    return os.path.join(directory, "libgstaichi_python.so")
 
 
 def print_red_bold(*args, **kwargs):
@@ -120,11 +120,11 @@ if log_level:
 
 def get_dll_name(name):
     if get_os_name() == "linux":
-        return f"libtaichi_{name}.so"
+        return f"libgstaichi_{name}.so"
     if get_os_name() == "osx":
-        return f"libtaichi_{name}.dylib"
+        return f"libgstaichi_{name}.dylib"
     if get_os_name() == "win":
-        return f"taichi_{name}.dll"
+        return f"gstaichi_{name}.dll"
     raise Exception(f"Unknown OS: {get_os_name()}")
 
 
@@ -141,8 +141,8 @@ def compare_version(latest, current):
     return tuple(latest_num) > tuple(current_num)
 
 
-def _print_taichi_header():
-    header = "[Taichi] "
+def _print_gstaichi_header():
+    header = "[GsTaichi] "
     header += f"version {ti_python_core.get_version_string()}, "
 
     try:
@@ -171,8 +171,8 @@ def _print_taichi_header():
     print(header)
 
 
-if os.getenv("ENABLE_TAICHI_HEADER_PRINT", "True").lower() not in ("false", "0", "f"):
-    _print_taichi_header()
+if os.getenv("ENABLE_GSTAICHI_HEADER_PRINT", "True").lower() not in ("false", "0", "f"):
+    _print_gstaichi_header()
 
 
 def try_get_wheel_tag(module):
@@ -218,28 +218,28 @@ def warn_restricted_version():
 
     if get_os_name() == "linux":
         try:
-            import taichi as ti  # pylint: disable=import-outside-toplevel
+            import gstaichi as ti  # pylint: disable=import-outside-toplevel
 
             wheel_tag = try_get_wheel_tag(ti)
             if wheel_tag and "manylinux2014" in wheel_tag:
                 print_yellow_bold(
-                    "You have installed a restricted version of taichi, certain features (e.g. Vulkan & GGUI) will not work."
+                    "You have installed a restricted version of gstaichi, certain features (e.g. Vulkan & GGUI) will not work."
                 )
                 libc_ver = try_get_loaded_libc_version()
                 if libc_ver and libc_ver < (2, 27):
                     print_yellow_bold(
-                        "!! Taichi requires glibc >= 2.27 to run, please try upgrading your OS to a recent one (e.g. Ubuntu 18.04 or later) if possible."
+                        "!! GsTaichi requires glibc >= 2.27 to run, please try upgrading your OS to a recent one (e.g. Ubuntu 18.04 or later) if possible."
                     )
 
                 pip_ver = try_get_pip_version()
                 if pip_ver and pip_ver < (20, 3, 0):
                     print_yellow_bold(
                         f"!! Your pip (version {'.'.join(map(str, pip_ver))}) is outdated (20.3.0 or later required), "
-                        "try upgrading pip and install taichi again."
+                        "try upgrading pip and install gstaichi again."
                     )
                     print()
                     print_yellow_bold("    $ python3 -m pip install --upgrade pip")
-                    print_yellow_bold("    $ python3 -m pip install --force-reinstall taichi")
+                    print_yellow_bold("    $ python3 -m pip install --force-reinstall gstaichi")
                     print()
 
                 print_yellow_bold(

{taichi → gstaichi}/_logging.py

@@ -3,7 +3,7 @@
 import inspect
 import os
 
-from taichi._lib import core as ti_python_core
+from gstaichi._lib import core as ti_python_core
 
 
 def _get_logging(name):

gstaichi/_snode/__init__.py

@@ -0,0 +1,5 @@
+# type: ignore
+
+from gstaichi._snode.fields_builder import FieldsBuilder
+
+__all__ = ["FieldsBuilder"]

{taichi → gstaichi}/_snode/fields_builder.py

@@ -2,12 +2,12 @@
 
 from typing import Any, Optional, Sequence, Union
 
-from taichi._lib import core as _ti_core
-from taichi._lib.core.taichi_python import SNode as SNodeCxx
-from taichi._snode.snode_tree import SNodeTree
-from taichi.lang import impl, snode
-from taichi.lang.exception import TaichiRuntimeError
-from taichi.lang.util import warning
+from gstaichi._lib import core as _ti_core
+from gstaichi._lib.core.gstaichi_python import SNodeCxx
+from gstaichi._snode.snode_tree import SNodeTree
+from gstaichi.lang import impl, snode
+from gstaichi.lang.exception import GsTaichiRuntimeError
+from gstaichi.lang.util import warning
 
 _snode_registry = _ti_core.SNodeRegistry()
 
@@ -61,7 +61,7 @@ class FieldsBuilder:
 
     # TODO: move this to SNodeTree class.
     def deactivate_all(self):
-        """Same as :func:`taichi.lang.snode.SNode.deactivate_all`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.deactivate_all`"""
         if self.finalized:
             self.root.deactivate_all()
         else:
@@ -72,7 +72,7 @@ class FieldsBuilder:
         indices: Union[Sequence[_Axis], _Axis],
         dimensions: Union[Sequence[int], int],
     ):
-        """Same as :func:`taichi.lang.snode.SNode.dense`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.dense`"""
         self._check_not_finalized()
         self.empty = False
         return self.root.dense(indices, dimensions)
@@ -82,15 +82,15 @@ class FieldsBuilder:
         indices: Union[Sequence[_Axis], _Axis],
         dimensions: Union[Sequence[int], int],
     ):
-        """Same as :func:`taichi.lang.snode.SNode.pointer`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.pointer`"""
         if not _ti_core.is_extension_supported(impl.current_cfg().arch, _ti_core.Extension.sparse):
-            raise TaichiRuntimeError("Pointer SNode is not supported on this backend.")
+            raise GsTaichiRuntimeError("Pointer SNode is not supported on this backend.")
         self._check_not_finalized()
         self.empty = False
         return self.root.pointer(indices, dimensions)
 
     def _hash(self, indices, dimensions):
-        """Same as :func:`taichi.lang.snode.SNode.hash`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.hash`"""
         raise NotImplementedError()
 
     def dynamic(
@@ -99,16 +99,16 @@ class FieldsBuilder:
         dimension: Union[Sequence[int], int],
         chunk_size: Optional[int] = None,
     ):
-        """Same as :func:`taichi.lang.snode.SNode.dynamic`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.dynamic`"""
         if not _ti_core.is_extension_supported(impl.current_cfg().arch, _ti_core.Extension.sparse):
-            raise TaichiRuntimeError("Dynamic SNode is not supported on this backend.")
+            raise GsTaichiRuntimeError("Dynamic SNode is not supported on this backend.")
 
         if dimension >= 2**31:
-            raise TaichiRuntimeError(
+            raise GsTaichiRuntimeError(
                 f"The maximum dimension of a dynamic SNode cannot exceed the maximum value of a 32-bit signed integer: Got {dimension} > 2**31-1"
             )
         if chunk_size is not None and chunk_size >= 2**31:
-            raise TaichiRuntimeError(
+            raise GsTaichiRuntimeError(
                 f"Chunk size cannot exceed the maximum value of a 32-bit signed integer: Got {chunk_size} > 2**31-1"
             )
 
@@ -121,9 +121,9 @@ class FieldsBuilder:
         indices: Union[Sequence[_Axis], _Axis],
         dimensions: Union[Sequence[int], int],
     ):
-        """Same as :func:`taichi.lang.snode.SNode.bitmasked`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.bitmasked`"""
         if not _ti_core.is_extension_supported(impl.current_cfg().arch, _ti_core.Extension.sparse):
-            raise TaichiRuntimeError("Bitmasked SNode is not supported on this backend.")
+            raise GsTaichiRuntimeError("Bitmasked SNode is not supported on this backend.")
         self._check_not_finalized()
         self.empty = False
         return self.root.bitmasked(indices, dimensions)
@@ -134,32 +134,32 @@ class FieldsBuilder:
         dimensions: Union[Sequence[int], int],
         max_num_bits: int,
     ):
-        """Same as :func:`taichi.lang.snode.SNode.quant_array`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.quant_array`"""
         self._check_not_finalized()
         self.empty = False
         return self.root.quant_array(indices, dimensions, max_num_bits)
 
     def place(self, *args: Any, offset: Optional[Union[Sequence[int], int]] = None):
-        """Same as :func:`taichi.lang.snode.SNode.place`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.place`"""
         self._check_not_finalized()
         self.empty = False
         self.root.place(*args, offset=offset)
 
     def lazy_grad(self):
-        """Same as :func:`taichi.lang.snode.SNode.lazy_grad`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.lazy_grad`"""
         # TODO: This complicates the implementation. Figure out why we need this
         self._check_not_finalized()
         self.empty = False
         self.root.lazy_grad()
 
     def _allocate_adjoint_checkbit(self):
-        """Same as :func:`taichi.lang.snode.SNode._allocate_adjoint_checkbit`"""
+        """Same as :func:`gstaichi.lang.snode.SNode._allocate_adjoint_checkbit`"""
         self._check_not_finalized()
         self.empty = False
         self.root._allocate_adjoint_checkbit()
 
     def lazy_dual(self):
-        """Same as :func:`taichi.lang.snode.SNode.lazy_dual`"""
+        """Same as :func:`gstaichi.lang.snode.SNode.lazy_dual`"""
         # TODO: This complicates the implementation. Figure out why we need this
         self._check_not_finalized()
         self.empty = False
@@ -172,18 +172,16 @@ class FieldsBuilder:
             raise_warning (bool): Raise warning or not."""
         return self._finalize(raise_warning, compile_only=False)
 
-    def _finalize_for_aot(self):
-        """Constructs the SNodeTree and compiles the type for AOT purpose."""
-        return self._finalize(raise_warning=False, compile_only=True)
-
-    def _finalize(self, raise_warning, compile_only):
+    def _finalize(self, raise_warning, compile_only) -> SNodeTree:
         self._check_not_finalized()
         if self.empty and raise_warning:
             warning("Finalizing an empty FieldsBuilder!")
         self.finalized = True
         impl.get_runtime().finalize_fields_builder(self)
-        return SNodeTree(_ti_core.finalize_snode_tree(_snode_registry, self.ptr, impl.get_runtime().prog, compile_only))
+        return SNodeTree(
+            _ti_core.finalize_snode_tree(_snode_registry, self.ptr, impl.get_runtime()._prog, compile_only)
+        )
 
     def _check_not_finalized(self):
         if self.finalized:
-            raise TaichiRuntimeError("FieldsBuilder finalized")
+            raise GsTaichiRuntimeError("FieldsBuilder finalized")

{taichi → gstaichi}/_snode/snode_tree.py

@@ -1,12 +1,12 @@
 # type: ignore
 
-# The reason we import just the taichi.core.util module, instead of the ti_python_core
+# The reason we import just the gstaichi.core.util module, instead of the ti_python_core
 # object within it, is that ti_python_core is stateful. While in practice ti_python_core is
 # loaded during the import procedure, it's probably still good to delay the
 # access to it.
 
-from taichi.lang import impl
-from taichi.lang.exception import TaichiRuntimeError
+from gstaichi.lang import impl
+from gstaichi.lang.exception import GsTaichiRuntimeError
 
 
 class SNodeTree:
@@ -17,7 +17,7 @@ class SNodeTree:
 
     def destroy(self):
         if self.destroyed:
-            raise TaichiRuntimeError("SNode tree has been destroyed")
+            raise GsTaichiRuntimeError("SNode tree has been destroyed")
         if self.prog != impl.get_runtime().prog:
             return
         self.ptr.destroy_snode_tree(impl.get_runtime().prog)
@@ -30,5 +30,5 @@ class SNodeTree:
     @property
     def id(self):
         if self.destroyed:
-            raise TaichiRuntimeError("SNode tree has been destroyed")
+            raise GsTaichiRuntimeError("SNode tree has been destroyed")
         return self.ptr.id()

gstaichi/_test_tools/load_kernel_string.py

@@ -0,0 +1,30 @@
+import importlib.util
+import sys
+import tempfile
+from contextlib import contextmanager
+from pathlib import Path
+
+
+def import_kernel_from_file(kernel_filepath: Path, kernel_name: str):
+    spec = importlib.util.spec_from_file_location(kernel_name, kernel_filepath)
+    assert spec is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[kernel_name] = module
+    loader = spec.loader
+    assert loader is not None
+    loader.exec_module(module)
+    return getattr(module, kernel_name)
+
+
+@contextmanager
+def load_kernel_from_string(kernel_str: str, kernel_name: str):
+    with tempfile.TemporaryDirectory() as temp_dir:
+        filepath = Path(temp_dir) / f"{kernel_name}.py"
+        with open(filepath, "w") as f:
+            f.write(kernel_str)
+        try:
+            kernel = import_kernel_from_file(kernel_filepath=filepath, kernel_name=kernel_name)
+            yield kernel
+        finally:
+            if kernel_name in sys.modules:
+                del sys.modules[kernel_name]

gstaichi/_version.py

@@ -0,0 +1 @@
+__version__ = '1.0.1'

{taichi → gstaichi}/_version_check.py

@@ -8,11 +8,11 @@ import threading
 import uuid
 from urllib import request
 
-from taichi._lib import core as _ti_core
+from gstaichi._lib import core as _ti_core
 
 
 def check_version(cur_uuid):
-    # Check Taichi version for the user.
+    # Check GsTaichi version for the user.
     major = _ti_core.get_version_major()
     minor = _ti_core.get_version_minor()
     patch = _ti_core.get_version_patch()
@@ -20,8 +20,11 @@ def check_version(cur_uuid):
     payload = {"version": version, "platform": "", "python": ""}
 
     system = platform.system()
-    if system == "Linux":
+    u = platform.uname()
+    if (u.system, u.machine) == ("Linux", "x86_64"):
         payload["platform"] = "manylinux_2_27_x86_64"
+    elif (u.system, u.machine) in (("Linux", "arm64"), ("Linux", "aarch64")):
+        payload["platform"] = "manylinux_2_27_aarch64"
     elif system == "Windows":
         payload["platform"] = "win_amd64"
     elif system == "Darwin":
@@ -38,11 +41,11 @@ def check_version(cur_uuid):
     payload["uuid"] = cur_uuid
     if os.getenv("TI_CI") == "1":
         payload["type"] = "CI"
-    # We do not want request exceptions break users' usage of Taichi.
+    # We do not want request exceptions break users' usage of GsTaichi.
     try:
         payload = json.dumps(payload)
         payload = payload.encode()
-        req = request.Request("https://metadata.taichi.graphics/check_version", method="POST")
+        req = request.Request("https://metadata.gstaichi.graphics/check_version", method="POST")
         req.add_header("Content-Type", "application/json")
         with request.urlopen(req, data=payload, timeout=5) as response:
             response = json.loads(response.read().decode("utf-8"))

gstaichi/ad/__init__.py

@@ -0,0 +1,3 @@
+# type: ignore
+
+from gstaichi.ad._ad import *

{taichi → gstaichi}/ad/_ad.py

@@ -1,6 +1,6 @@
 # type: ignore
 
-"""Taichi automatic differentiation module.
+"""GsTaichi automatic differentiation module.
 
 This module supplies two decorators for users to customize their
 gradient computation task.
@@ -11,16 +11,16 @@ from functools import reduce
 
 import numpy as np
 
-import taichi.types.primitive_types as types
-from taichi import _snode
-from taichi.lang import impl
-from taichi.lang._ndarray import Ndarray
-from taichi.lang.expr import Expr
-from taichi.lang.field import Field, ScalarField
-from taichi.lang.kernel_impl import kernel
-from taichi.lang.snode import SNode
-from taichi.types import ndarray, template
-from taichi.types.enums import AutodiffMode, SNodeGradType
+import gstaichi.types.primitive_types as types
+from gstaichi import _snode
+from gstaichi.lang import impl
+from gstaichi.lang._ndarray import Ndarray
+from gstaichi.lang.expr import Expr
+from gstaichi.lang.field import Field, ScalarField
+from gstaichi.lang.kernel_impl import kernel
+from gstaichi.lang.snode import SNode
+from gstaichi.types import ndarray, template
+from gstaichi.types.enums import AutodiffMode, SNodeGradType
 
 
 class GradChecker:
@@ -140,19 +140,19 @@ def restore_all_fields(all_fields, backups):
 
 class Tape:
     def __init__(self, loss=None, clear_gradients=True, validation=False, grad_check=None):
-        """A context manager for reverse mode autodiff :class:`~taichi.ad.Tape`. The
+        """A context manager for reverse mode autodiff :class:`~gstaichi.ad.Tape`. The
         context manager would catching all of the callings of functions that
-        decorated by :func:`~taichi.lang.kernel_impl.kernel` or
-        :func:`~taichi.ad.grad_replaced` under `with` statement, and calculate
+        decorated by :func:`~gstaichi.lang.kernel_impl.kernel` or
+        :func:`~gstaichi.ad.grad_replaced` under `with` statement, and calculate
         all the partial gradients of a given loss variable by calling all of the
         gradient function of the callings caught in reverse order while `with`
         statement ended.
 
-        See also :func:`~taichi.lang.kernel_impl.kernel` and
-        :func:`~taichi.ad.grad_replaced` for gradient functions.
+        See also :func:`~gstaichi.lang.kernel_impl.kernel` and
+        :func:`~gstaichi.ad.grad_replaced` for gradient functions.
 
         Args:
-            loss(:class:`~taichi.lang.expr.Expr`): The loss field, which shape should be ().
+            loss(:class:`~gstaichi.lang.expr.Expr`): The loss field, which shape should be ().
             clear_gradients(Bool): Before `with` body start, clear all gradients or not.
             validation(Bool): Check whether the code inside the context manager is autodiff valid, e.g., agree with the global data access rule.
             grad_check(List[Field]): List of fields that need to check gradients.
@@ -293,7 +293,7 @@ def clear_all_gradients(gradient_type=SNodeGradType.ADJOINT):
 
         places = tuple(places)
         if places:
-            from taichi._kernels import clear_gradients  # pylint: disable=C0415
+            from gstaichi._kernels import clear_gradients  # pylint: disable=C0415
 
             clear_gradients(places)
 
@@ -302,12 +302,12 @@ def clear_all_gradients(gradient_type=SNodeGradType.ADJOINT):
 
 
 def grad_replaced(func):
-    """A decorator for python function to customize gradient with Taichi's autodiff
+    """A decorator for python function to customize gradient with GsTaichi's autodiff
     system, e.g. `ti.ad.Tape()` and `kernel.grad()`.
 
-    This decorator forces Taichi's autodiff system to use a user-defined gradient
+    This decorator forces GsTaichi's autodiff system to use a user-defined gradient
     function for the decorated function. Its customized gradient must be decorated
-    by :func:`~taichi.ad.grad_for`.
+    by :func:`~gstaichi.ad.grad_for`.
 
     Args:
         fn (Callable): The python function to be decorated.
@@ -353,10 +353,10 @@ def grad_replaced(func):
 def grad_for(primal):
     """Generates a decorator to decorate `primal`'s customized gradient function.
 
-    See :func:`~taichi.lang.grad_replaced` for examples.
+    See :func:`~gstaichi.lang.grad_replaced` for examples.
 
     Args:
-        primal (Callable): The primal function, must be decorated by :func:`~taichi.ad.grad_replaced`.
+        primal (Callable): The primal function, must be decorated by :func:`~gstaichi.ad.grad_replaced`.
 
     Returns:
         Callable: The decorator used to decorate customized gradient function."""
@@ -369,7 +369,7 @@ def grad_for(primal):
             raise RuntimeError(f"Primal function `{primal.__name__}` must be decorated by ti.ad.grad_replaced")
         if primal.grad is not None:
             raise RuntimeError(
-                "Primal function must be a **python** function instead of a taichi kernel. Please wrap the taichi kernel in a @ti.ad.grad_replaced decorated python function instead."
+                "Primal function must be a **python** function instead of a gstaichi kernel. Please wrap the gstaichi kernel in a @ti.ad.grad_replaced decorated python function instead."
             )
         primal.grad = decorated
         return decorated
@@ -378,9 +378,9 @@ def grad_for(primal):
 
 
 def no_grad(func):
-    """A decorator for python function to skip gradient calculation within Taichi's
+    """A decorator for python function to skip gradient calculation within GsTaichi's
     autodiff system, e.g. `ti.ad.Tape()` and `kernel.grad()`.
-    This decorator forces Taichi's autodiff system to use an empty gradient function
+    This decorator forces GsTaichi's autodiff system to use an empty gradient function
     for the decorated function.
 
     Args:

{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",
+    ]
+]