Format code with ruff (56 files)

Author: CyberSnakeH

src/mathviz/cli.py

@@ -271,7 +271,9 @@ def __str__(self) -> str:
         lines.append(f"  JIT Compatible: {self.is_jit_compatible}")
         if self.parallelizable_loops:
             parallel_count = sum(1 for l in self.parallelizable_loops if l.is_parallelizable)
-            lines.append(f"  Parallelizable Loops: {parallel_count}/{len(self.parallelizable_loops)}")
+            lines.append(
+                f"  Parallelizable Loops: {parallel_count}/{len(self.parallelizable_loops)}"
+            )
         if self.suggested_optimizations:
             lines.append("  Suggested Optimizations:")
             for opt in self.suggested_optimizations:
@@ -321,7 +323,9 @@ def __str__(self) -> str:
         if self.function_analysis:
             lines.append(f"  Functions Analyzed: {len(self.function_analysis)}")
         if self.call_graph:
-            lines.append(f"  Call Graph: {len(self.call_graph.nodes)} nodes, {len(self.call_graph.edges)} edges")
+            lines.append(
+                f"  Call Graph: {len(self.call_graph.nodes)} nodes, {len(self.call_graph.edges)} edges"
+            )
         lines.append(f"  Generated Code: {len(self.python_code)} characters")
         return "\n".join(lines)
 
@@ -332,14 +336,14 @@ def has_errors(self) -> bool:
     def get_jit_compatible_functions(self) -> list[str]:
         """Get names of all JIT-compatible functions."""
         return [
-            name for name, analysis in self.function_analysis.items()
-            if analysis.is_jit_compatible
+            name for name, analysis in self.function_analysis.items() if analysis.is_jit_compatible
         ]
 
     def get_parallelizable_functions(self) -> list[str]:
         """Get names of functions with parallelizable loops."""
         return [
-            name for name, analysis in self.function_analysis.items()
+            name
+            for name, analysis in self.function_analysis.items()
             if any(loop.is_parallelizable for loop in analysis.parallelizable_loops)
         ]
 
@@ -507,9 +511,7 @@ def compile(self, source: str, filename: str = "<string>") -> CompilationResult:
                 return result
 
             if type_errors:
-                warnings.append(
-                    f"Type checking found {len(type_errors)} error(s)"
-                )
+                warnings.append(f"Type checking found {len(type_errors)} error(s)")
 
         # Stage 4: Build Call Graph
         call_graph_builder = CallGraphBuilder()
@@ -625,9 +627,7 @@ def _aggregate_function_analysis(
                 # Get parallelization analysis
                 loop_analyses: list[LoopAnalysis] = []
                 if func_name in parallel_results:
-                    loop_analyses = [
-                        analysis for _, analysis in parallel_results[func_name]
-                    ]
+                    loop_analyses = [analysis for _, analysis in parallel_results[func_name]]
 
                 # Determine JIT compatibility
                 is_jit_compatible = is_jit_safe(purity_info) and not purity_info.has_manim_calls()
@@ -674,8 +674,7 @@ def _generate_optimization_suggestions(
                 )
             if analysis.purity.has_manim_calls():
                 suggestions.append(
-                    f"Function '{analysis.name}' contains Manim calls; "
-                    "move to scene methods"
+                    f"Function '{analysis.name}' contains Manim calls; move to scene methods"
                 )
 
         # Complexity-based suggestions
@@ -700,14 +699,10 @@ def _generate_optimization_suggestions(
                         f"reduction variables: {', '.join(loop_analysis.reduction_vars)}"
                     )
                 else:
-                    suggestions.append(
-                        f"Loop in '{analysis.name}' can be parallelized with prange"
-                    )
+                    suggestions.append(f"Loop in '{analysis.name}' can be parallelized with prange")
             else:
                 for transform in loop_analysis.suggested_transforms:
-                    suggestions.append(
-                        f"In '{analysis.name}': {transform}"
-                    )
+                    suggestions.append(f"In '{analysis.name}': {transform}")
 
 
 # =============================================================================
@@ -736,7 +731,7 @@ def compile_source(source: str, optimize: bool = True) -> str:
         optimize=optimize,
         check_types=True,
         analyze_complexity=False,  # Skip for simple compilation
-        auto_parallelize=False,    # Skip for simple compilation
+        auto_parallelize=False,  # Skip for simple compilation
         strict=False,
     )
     result = pipeline.compile(source)

src/mathviz/compiler/__init__.py

@@ -595,15 +595,15 @@ class BinaryOperator(Enum):
     OR = auto()
 
     # Set operations (mathematical)
-    ELEMENT_OF = auto()       # ∈
-    NOT_ELEMENT_OF = auto()   # ∉
-    SUBSET = auto()           # ⊆
-    SUPERSET = auto()         # ⊇
-    PROPER_SUBSET = auto()    # ⊂
+    ELEMENT_OF = auto()  # ∈
+    NOT_ELEMENT_OF = auto()  # ∉
+    SUBSET = auto()  # ⊆
+    SUPERSET = auto()  # ⊇
+    PROPER_SUBSET = auto()  # ⊂
     PROPER_SUPERSET = auto()  # ⊃
-    UNION = auto()            # ∪
-    INTERSECTION = auto()     # ∩
-    SET_DIFF = auto()         # ∖
+    UNION = auto()  # ∪
+    INTERSECTION = auto()  # ∩
+    SET_DIFF = auto()  # ∖
 
     # Membership (Python-style)
     IN = auto()
@@ -613,9 +613,9 @@ class BinaryOperator(Enum):
 class UnaryOperator(Enum):
     """Unary operator types."""
 
-    NEG = auto()      # -
-    NOT = auto()      # not
-    POS = auto()      # +
+    NEG = auto()  # -
+    NOT = auto()  # not
+    POS = auto()  # +
 
 
 @dataclass(frozen=True, slots=True)
@@ -1013,7 +1013,7 @@ class RangePattern(Pattern):
     """
 
     start: Expression  # Inclusive start
-    end: Expression    # Exclusive end (or inclusive with ..=)
+    end: Expression  # Exclusive end (or inclusive with ..=)
     inclusive: bool = False  # True for ..= (inclusive end)
     location: Optional[SourceLocation] = None
 
@@ -1332,13 +1332,14 @@ def accept(self, visitor: ASTVisitor) -> Any:
 
 class JitMode(Enum):
     """JIT compilation modes for Numba optimization."""
-    NONE = "none"           # No JIT compilation
-    JIT = "jit"             # Standard @jit decorator
-    NJIT = "njit"           # @njit (nopython=True, faster)
-    VECTORIZE = "vectorize" # @vectorize for ufuncs
+
+    NONE = "none"  # No JIT compilation
+    JIT = "jit"  # Standard @jit decorator
+    NJIT = "njit"  # @njit (nopython=True, faster)
+    VECTORIZE = "vectorize"  # @vectorize for ufuncs
     GUVECTORIZE = "guvectorize"  # @guvectorize for generalized ufuncs
-    STENCIL = "stencil"     # @stencil for stencil computations
-    CFUNC = "cfunc"         # @cfunc for C-callable functions
+    STENCIL = "stencil"  # @stencil for stencil computations
+    CFUNC = "cfunc"  # @cfunc for C-callable functions
 
 
 @dataclass(frozen=True, slots=True)
@@ -1348,14 +1349,15 @@ class JitOptions:
 
     These map directly to Numba decorator arguments.
     """
+
     mode: JitMode = JitMode.NONE
-    nopython: bool = True       # Compile in nopython mode (faster, stricter)
-    nogil: bool = False         # Release GIL (for parallel execution)
-    cache: bool = True          # Cache compiled function to disk
-    parallel: bool = False      # Enable automatic parallelization
-    fastmath: bool = False      # Use fast math (less precise, faster)
-    boundscheck: bool = False   # Check array bounds (slower but safer)
-    inline: str = "never"       # Inlining: "never", "always", or "recursive"
+    nopython: bool = True  # Compile in nopython mode (faster, stricter)
+    nogil: bool = False  # Release GIL (for parallel execution)
+    cache: bool = True  # Cache compiled function to disk
+    parallel: bool = False  # Enable automatic parallelization
+    fastmath: bool = False  # Use fast math (less precise, faster)
+    boundscheck: bool = False  # Check array bounds (slower but safer)
+    inline: str = "never"  # Inlining: "never", "always", or "recursive"
 
     def to_decorator_args(self) -> str:
         """Generate the decorator argument string."""
@@ -1457,6 +1459,7 @@ def get_test_description(self) -> str | None:
         for attr in self.attributes:
             if attr.name == "test" and attr.arguments:
                 from mathviz.compiler.ast_nodes import StringLiteral
+
                 if isinstance(attr.arguments[0], StringLiteral):
                     return attr.arguments[0].value
         return None
@@ -1890,7 +1893,7 @@ class Visibility(Enum):
     """Visibility modifier for struct fields and methods."""
 
     PRIVATE = auto()  # Default visibility
-    PUBLIC = auto()   # pub keyword
+    PUBLIC = auto()  # pub keyword
 
 
 @dataclass(frozen=True, slots=True)
@@ -2028,7 +2031,9 @@ class ImplBlock(Statement):
 
     target_type: str  # The struct/type being implemented
     trait_name: Optional[str] = None  # None for inherent impl, trait name for trait impl
-    trait_type_args: tuple[TypeAnnotation, ...] = ()  # Type args for trait (e.g., Float in Mul<Float>)
+    trait_type_args: tuple[
+        TypeAnnotation, ...
+    ] = ()  # Type args for trait (e.g., Float in Mul<Float>)
     methods: tuple[Method, ...] = ()
     associated_types: tuple[AssociatedType, ...] = ()  # Associated type declarations
     type_params: tuple["TypeParameter", ...] = ()
@@ -2045,6 +2050,7 @@ def is_generic(self) -> bool:
     def is_operator_impl(self) -> bool:
         """Check if this impl block is for an operator trait."""
         from mathviz.compiler.operators import OPERATOR_TRAITS
+
         return self.trait_name is not None and self.trait_name in OPERATOR_TRAITS
 
     def accept(self, visitor: ASTVisitor) -> Any:

src/mathviz/compiler/ast_nodes.py

@@ -285,9 +285,7 @@ def topological_sort(self) -> list[str]:
         # Check if we processed all nodes
         if len(result) != len(self.nodes):
             cycles = self.find_cycles()
-            cycle_desc = ", ".join(
-                " -> ".join(cycle) for cycle in cycles
-            )
+            cycle_desc = ", ".join(" -> ".join(cycle) for cycle in cycles)
             raise CallGraphError(
                 f"Cannot compute topological sort: graph contains cycles ({cycle_desc})",
                 cycles=cycles,
@@ -472,10 +470,7 @@ def get_transitive_callers(self, func: str) -> set[str]:
         return visited
 
     def __repr__(self) -> str:
-        return (
-            f"CallGraph(nodes={len(self.nodes)}, "
-            f"edges={len(self.edges)})"
-        )
+        return f"CallGraph(nodes={len(self.nodes)}, edges={len(self.edges)})"
 
     def __str__(self) -> str:
         lines = ["CallGraph:"]
@@ -592,9 +587,7 @@ def visit_class_def(self, node: ClassDef) -> None:
 
                     self._function_scope_stack.pop()
                     self._current_function = (
-                        self._function_scope_stack[-1]
-                        if self._function_scope_stack
-                        else None
+                        self._function_scope_stack[-1] if self._function_scope_stack else None
                     )
                 else:
                     self.visit(stmt)
@@ -617,9 +610,7 @@ def visit_scene_def(self, node: SceneDef) -> None:
 
                     self._function_scope_stack.pop()
                     self._current_function = (
-                        self._function_scope_stack[-1]
-                        if self._function_scope_stack
-                        else None
+                        self._function_scope_stack[-1] if self._function_scope_stack else None
                     )
                 else:
                     self.visit(stmt)
@@ -641,9 +632,7 @@ def visit_module_decl(self, node: ModuleDecl) -> None:
 
                 self._function_scope_stack.pop()
                 self._current_function = (
-                    self._function_scope_stack[-1]
-                    if self._function_scope_stack
-                    else None
+                    self._function_scope_stack[-1] if self._function_scope_stack else None
                 )
             else:
                 self.visit(stmt)