[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

python/taichi/ad/_ad.py

@@ -3,6 +3,7 @@
 This module supplies two decorators for users to customize their
 gradient computation task.
 """
+
 import warnings
 from functools import reduce
 

python/taichi/aot/__init__.py

@@ -3,6 +3,7 @@
 Users can use Taichi as a GPU compute shader/kernel compiler by compiling their
 Taichi kernels into an AOT module.
 """
+
 import taichi.aot.conventions
 from taichi.aot._export import export, export_as
 from taichi.aot.conventions.gfxruntime140 import GfxRuntime140

python/taichi/aot/conventions/gfxruntime140/dr.py

@@ -2,6 +2,7 @@
 Data representation of all JSON data structures following the GfxRuntime140
 convention.
 """
+
 from typing import Any, Dict, List, Optional
 
 from taichi.aot.utils import dump_json_data_model, json_data_model

python/taichi/aot/conventions/gfxruntime140/sr.py

@@ -2,6 +2,7 @@
 Structured representation of all JSON data structures following the
 GfxRuntime140.
 """
+
 from abc import ABC
 from enum import Enum
 from typing import Any, Dict, List, Optional

python/taichi/examples/algorithm/circle-packing/circle_packing_image.py

@@ -1,6 +1,7 @@
 """
 Given an input image, redraw it with circle packings.
 """
+
 try:
     import cairo
     import cv2

python/taichi/examples/algorithm/marching_squares.py

@@ -2,6 +2,7 @@
 Marching squares algorithm in Taichi.
 See "https://en.wikipedia.org/wiki/Marching_squares"
 """
+
 import time
 
 import numpy as np

python/taichi/examples/algorithm/poisson_disk_sampling.py

@@ -7,6 +7,7 @@
 1. Click on the window to restart the animation.
 2. Press `p` to save screenshot.
 """
+
 import taichi as ti
 import taichi.math as tm
 

python/taichi/examples/real_func/algorithm/marching_squares.py

@@ -2,6 +2,7 @@
 Marching squares algorithm in Taichi.
 See "https://en.wikipedia.org/wiki/Marching_squares"
 """
+
 import time
 
 import numpy as np

python/taichi/examples/real_func/algorithm/poisson_disk_sampling.py

@@ -7,6 +7,7 @@
 1. Click on the window to restart the animation.
 2. Press `p` to save screenshot.
 """
+
 import taichi as ti
 import taichi.math as tm
 import typing

python/taichi/examples/real_func/rendering/taichi_ngp.py

@@ -277,9 +277,7 @@ def hash_table_init(self):
         for i in range(self.level):
             resolution = int(np.ceil(self.base_res * np.exp(i * np.log(self.per_level_scales)) - 1.0)) + 1
             params_in_level = resolution**3
-            params_in_level = (
-                int(resolution**3) if params_in_level % 8 == 0 else int((params_in_level + 8 - 1) / 8) * 8
-            )
+            params_in_level = int(resolution**3) if params_in_level % 8 == 0 else int((params_in_level + 8 - 1) / 8) * 8
             params_in_level = min(self.max_params, params_in_level)
             self.offsets[i] = offset
             self.hash_map_sizes[i] = params_in_level

python/taichi/examples/rendering/taichi_ngp.py

@@ -277,9 +277,7 @@ def hash_table_init(self):
         for i in range(self.level):
             resolution = int(np.ceil(self.base_res * np.exp(i * np.log(self.per_level_scales)) - 1.0)) + 1
             params_in_level = resolution**3
-            params_in_level = (
-                int(resolution**3) if params_in_level % 8 == 0 else int((params_in_level + 8 - 1) / 8) * 8
-            )
+            params_in_level = int(resolution**3) if params_in_level % 8 == 0 else int((params_in_level + 8 - 1) / 8) * 8
             params_in_level = min(self.max_params, params_in_level)
             self.offsets[i] = offset
             self.hash_map_sizes[i] = params_in_level

python/taichi/examples/simulation/snow_phaseField.py

@@ -2,6 +2,7 @@
     space discretization: finite difference method, time integration: Runge-Kutta method
     repo's link: https://github.com/mo-hanxuan/Snow-PhaseField
     more details about physical interpretation refer to [Physica D 63(3-4): 410-423]"""
+
 import numpy as np
 
 import taichi as ti

python/taichi/examples/simulation/waterwave.py

@@ -31,9 +31,7 @@ def reset():
 
 @ti.func
 def laplacian(i, j):
-    return (-4 * height[i, j] + height[i, j - 1] + height[i, j + 1] + height[i + 1, j] + height[i - 1, j]) / (
-        4 * dx**2
-    )
+    return (-4 * height[i, j] + height[i, j - 1] + height[i, j + 1] + height[i + 1, j] + height[i - 1, j]) / (4 * dx**2)
 
 
 @ti.func

python/taichi/lang/ast/symbol_resolver.py

@@ -1,4 +1,5 @@
 """Provides helpers to resolve AST nodes."""
+
 import ast
 
 

python/taichi/lang/struct.py

@@ -210,11 +210,11 @@ def to_dict(self, include_methods=False, include_ndim=False):
             Dict: The result dictionary.
         """
         res_dict = {
-            k: v.to_dict(include_methods=include_methods, include_ndim=include_ndim)
-            if isinstance(v, Struct)
-            else v.to_list()
-            if isinstance(v, Matrix)
-            else v
+            k: (
+                v.to_dict(include_methods=include_methods, include_ndim=include_ndim)
+                if isinstance(v, Struct)
+                else v.to_list() if isinstance(v, Matrix) else v
+            )
             for k, v in self.__entries.items()
         }
         if include_methods:

python/taichi/linalg/__init__.py

@@ -1,5 +1,6 @@
 """Taichi support module for sparse matrix operations.
 """
+
 from taichi.linalg.sparse_cg import SparseCG
 from taichi.linalg.sparse_matrix import *
 from taichi.linalg.sparse_solver import SparseSolver

python/taichi/math/__init__.py

@@ -2,6 +2,7 @@
 
 The math module supports glsl-style vectors, matrices and functions.
 """
+
 from ._complex import *
 from .mathimpl import *  # pylint: disable=W0622
 

python/taichi/tools/__init__.py

@@ -4,6 +4,7 @@
 - `video` submodule for exporting results to video files.
 - `diagnose` submodule for printing system environment information.
 """
+
 from taichi.tools.diagnose import *
 from taichi.tools.image import *
 from taichi.tools.np2ply import *

python/taichi/types/__init__.py

@@ -7,6 +7,7 @@
 - ndarray: for arbitrary arrays.
 - quant: for quantized types, see "https://yuanming.taichi.graphics/publication/2021-quantaichi/quantaichi.pdf"
 """
+
 from taichi.types import quant
 from taichi.types.annotations import *
 from taichi.types.compound_types import *

python/taichi/types/quant.py

@@ -2,6 +2,7 @@
 This module defines generators of quantized types.
 For more details, read https://yuanming.taichi.graphics/publication/2021-quantaichi/quantaichi.pdf.
 """
+
 from taichi._lib.utils import ti_python_core as _ti_python_core
 from taichi.lang import impl
 from taichi.types.primitive_types import i32

python/taichi/ui/__init__.py

@@ -4,5 +4,6 @@
 This module contains a cpu based GUI system, a vulkan based GGUI system,
 and other helper utilities like adding widgets and exporting video files.
 """
+
 from .gui import *
 from .ui import *

taichi/analysis/gen_offline_cache_key.cpp

@@ -630,7 +630,9 @@ class ASTSerializer : public IRVisitor, public ExpressionVisitor {
   }
 
 #define DEFINE_EMIT_ENUM(EnumType) \
-  void emit(EnumType type) { emit_pod(type); }
+  void emit(EnumType type) {       \
+    emit_pod(type);                \
+  }
 
   DEFINE_EMIT_ENUM(ExprOpCode);
   DEFINE_EMIT_ENUM(StmtOpCode);

taichi/codegen/spirv/kernel_utils.h

@@ -315,8 +315,8 @@ class KernelContextAttributes {
   /**
    * Get all argpacks.
    */
-  inline const std::vector<std::pair<std::vector<int>, const Type *>>
-      &argpack_types() const {
+  inline const std::vector<std::pair<std::vector<int>, const Type *>> &
+  argpack_types() const {
     return argpack_types_;
   }
 

taichi/common/dict.h

@@ -188,8 +188,8 @@ class Dict {
   }
 
   template <typename T>
-  std::enable_if_t<std::is_reference<T>::value, std::remove_reference_t<T>>
-      &get(std::string key) const {
+  std::enable_if_t<std::is_reference<T>::value, std::remove_reference_t<T>> &
+  get(std::string key) const {
     return *get_ptr<std::remove_reference_t<T>>(key);
   }
 

taichi/common/exceptions.h

@@ -135,8 +135,8 @@ struct ErrorEmitter {
                 std::string>>>
   ErrorEmitter(E &&error, T p_dbg_info, std::string &&error_msg) {
     if constexpr ((std::is_same_v<std::decay_t<T>, DebugInfo *> ||
-                   std::is_same_v<std::decay_t<T>, const DebugInfo *>)&&std::
-                      is_base_of_v<TaichiError, std::decay_t<E>>) {
+                   std::is_same_v<std::decay_t<T>, const DebugInfo *>) &&
+                  std::is_base_of_v<TaichiError, std::decay_t<E>>) {
       // Indicates a failed C++ API call from Python side, we should not print
       // tb here
       error.msg_ = error_msg;

taichi/common/interface.h

@@ -325,8 +325,12 @@ class InterfaceHolder {
     }                                                                \
   } ImplementationInjector_##base_class_name##class_name##instance;
 
-#define TI_NAME(alias)                                                        \
-  virtual std::string get_name() const override { return get_name_static(); } \
-  static std::string get_name_static() { return alias; }
+#define TI_NAME(alias)                            \
+  virtual std::string get_name() const override { \
+    return get_name_static();                     \
+  }                                               \
+  static std::string get_name_static() {          \
+    return alias;                                 \
+  }
 
 }  // namespace taichi

taichi/common/json_serde.h

@@ -88,12 +88,13 @@ using remove_cvref_t = typename remove_cvref<T>::type;
 template <typename T>
 struct has_ptr_serde {
   template <typename T_>
-  static constexpr auto helper(T_ *) -> std::is_same<
-      decltype((T_::jsonserde_ptr_io(std::declval<const T_ *&>(),
-                                     std::declval<JsonValue &>(),
-                                     std::declval<bool>(),
-                                     std::declval<bool>()))),
-      void>;
+  static constexpr auto helper(T_ *)
+      -> std::is_same<
+          decltype((T_::jsonserde_ptr_io(std::declval<const T_ *&>(),
+                                         std::declval<JsonValue &>(),
+                                         std::declval<bool>(),
+                                         std::declval<bool>()))),
+          void>;
 
   template <typename>
   static constexpr auto helper(...) -> std::false_type;

taichi/common/serialization.h

@@ -193,9 +193,10 @@ class Serializer {
   template <typename T>
   struct has_io {
     template <typename T_>
-    static constexpr auto helper(T_ *) -> std::is_same<
-        decltype((std::declval<T_>().io(std::declval<Serializer &>()))),
-        void>;
+    static constexpr auto helper(T_ *)
+        -> std::is_same<
+            decltype((std::declval<T_>().io(std::declval<Serializer &>()))),
+            void>;
 
     template <typename>
     static constexpr auto helper(...) -> std::false_type;

taichi/ir/expression.h

@@ -175,7 +175,9 @@ class ExpressionVisitor {
   bool invoke_default_visitor_{false};
 };
 
-#define TI_DEFINE_ACCEPT_FOR_EXPRESSION \
-  void accept(ExpressionVisitor *visitor) override { visitor->visit(this); }
+#define TI_DEFINE_ACCEPT_FOR_EXPRESSION              \
+  void accept(ExpressionVisitor *visitor) override { \
+    visitor->visit(this);                            \
+  }
 
 }  // namespace taichi::lang

taichi/ir/expression_ops.h

@@ -12,19 +12,25 @@
   Expr expr_##opname(const Expr &expr) {                             \
     return Expr::make<UnaryOpExpression>(UnaryOpType::opname, expr); \
   }                                                                  \
-  Expr operator op(const Expr &expr) { return expr_##opname(expr); }
+  Expr operator op(const Expr &expr) {                               \
+    return expr_##opname(expr);                                      \
+  }
 
 #define DEFINE_EXPRESSION_FUNC_UNARY(opname)                         \
   Expr opname(const Expr &expr) {                                    \
     return Expr::make<UnaryOpExpression>(UnaryOpType::opname, expr); \
   }                                                                  \
-  Expr expr_##opname(const Expr &expr) { return opname(expr); }
+  Expr expr_##opname(const Expr &expr) {                             \
+    return opname(expr);                                             \
+  }
 
 #define DEFINE_EXPRESSION_OP_BINARY(op, opname)                            \
   Expr operator op(const Expr &lhs, const Expr &rhs) {                     \
     return Expr::make<BinaryOpExpression>(BinaryOpType::opname, lhs, rhs); \
   }                                                                        \
-  Expr expr_##opname(const Expr &lhs, const Expr &rhs) { return lhs op rhs; }
+  Expr expr_##opname(const Expr &lhs, const Expr &rhs) {                   \
+    return lhs op rhs;                                                     \
+  }
 
 #define DEFINE_EXPRESSION_FUNC_BINARY(opname)                              \
   Expr opname(const Expr &lhs, const Expr &rhs) {                          \

taichi/ir/ir.cpp

@@ -61,8 +61,9 @@ class StatementTypeNameVisitor : public IRVisitor {
   StatementTypeNameVisitor() {
   }
 
-#define PER_STATEMENT(x) \
-  void visit(x *stmt) override { type_name = #x; }
+#define PER_STATEMENT(x)                       \
+  void visit(x *stmt) override{type_name = #x; \
+  }
 #include "taichi/inc/statements.inc.h"
 
 #undef PER_STATEMENT

taichi/ir/ir.h

@@ -268,8 +268,10 @@ class IRNode {
   std::unique_ptr<IRNode> clone();
 };
 
-#define TI_DEFINE_ACCEPT \
-  void accept(IRVisitor *visitor) override { visitor->visit(this); }
+#define TI_DEFINE_ACCEPT                     \
+  void accept(IRVisitor *visitor) override { \
+    visitor->visit(this);                    \
+  }
 
 #define TI_DEFINE_CLONE                                             \
   std::unique_ptr<Stmt> clone() const override {                    \

taichi/program/field_info.h

@@ -13,10 +13,14 @@ enum class FieldSource : int {
   HostMappedPtr = 1,
 };
 
-#define DEFINE_PROPERTY(Type, name)                          \
-  Type name;                                                 \
-  void set_##name(const Type &new_name) { name = new_name; } \
-  Type get_##name() { return name; }
+#define DEFINE_PROPERTY(Type, name)       \
+  Type name;                              \
+  void set_##name(const Type &new_name) { \
+    name = new_name;                      \
+  }                                       \
+  Type get_##name() {                     \
+    return name;                          \
+  }
 
 struct FieldInfo {
   DEFINE_PROPERTY(bool, valid)

taichi/program/kernel.cpp

@@ -27,8 +27,7 @@ Kernel::Kernel(Program &program,
                const std::string &primal_name,
                AutodiffMode autodiff_mode) {
   // due to #6362, we cannot write [func, this] { return func(this); }
-  this->init(
-      program, [&] { return func(this); }, primal_name, autodiff_mode);
+  this->init(program, [&] { return func(this); }, primal_name, autodiff_mode);
 }
 
 Kernel::Kernel(Program &program,

taichi/program/kernel_profiler.h

@@ -68,15 +68,16 @@ class KernelProfilerBase {
   }
 
   // TODO: remove start and always use start_with_handle
-  virtual void start(const std::string &kernel_name){TI_NOT_IMPLEMENTED};
+  virtual void start(const std::string &kernel_name) { TI_NOT_IMPLEMENTED };
 
-  virtual TaskHandle start_with_handle(const std::string &kernel_name){
-      TI_NOT_IMPLEMENTED};
+  virtual TaskHandle start_with_handle(const std::string &kernel_name) {
+    TI_NOT_IMPLEMENTED
+  };
 
   static void profiler_start(KernelProfilerBase *profiler,
                              const char *kernel_name);
 
-  virtual void stop(){TI_NOT_IMPLEMENTED};
+  virtual void stop() { TI_NOT_IMPLEMENTED };
 
   virtual void stop(TaskHandle){TI_NOT_IMPLEMENTED};