[Feature] add execution time to autoformat (#23)

Author: RektPunk

.pre-commit-config.yaml

@@ -11,14 +11,12 @@ repos:
     - id: check-merge-conflict
 
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: v0.14.8
+  rev: v0.15.2
   hooks:
     - id: ruff-check
+      name: ruff check fix
       args: [ --fix ]
+    - id: ruff-check
+      name: ruff isort
+      args: [--select, I, --fix]
     - id: ruff-format
-
-- repo: https://github.com/pycqa/isort
-  rev: 7.0.0
-  hooks:
-    - id: isort
-      args: ["--profile", "black"]

README.md

@@ -5,22 +5,20 @@
 
 ## Overview
 
-**`colablinter`** is an **IPython magic command extension** designed specifically for Jupyter and Google Colab notebooks.
-
-It integrates the high-speed linter **`ruff`** to perform code quality checks and enforce standards directly within Jupyter/Colab cells.
-
-It allows developers to lint and format code on a **cell-by-cell** basis or check the **entire notebook** with simple commands.
+**`colablinter`** is an **IPython magic command extension** designed for Jupyter and Google Colab notebooks.
+It integrates the high-speed linter **`ruff`** to perform code quality checks and formatting directly within Jupyter/Colab cells.
+It allows developers to lint code on a **cell-by-cell** basis or the **entire notebook** with simple commands.
 
 ## Magic cell Commands
 
-| Command | Type | Description |
-| :--- | :--- | :--- |
-| **`%%cfix`** | Cell Magic | Fixes and Formats the current cell's code. |
-| **`%%creport`** | Cell Magic | Displays a linting report for the current cell. |
-| **`%clautofix`** | Line Magic | Activates or deactivates automatic code fixing and formatting before every cell execution. |
-| **`%clreport`** | Line Magic | Displays a linting report for the **entire saved notebook** (requires Google Drive mount). |
+| Command | Description |
+| :--- | :--- |
+| **`%%cformat`** | Sorts imports and Formats the current cell's code. |
+| **`%%ccheck`** | Displays a linting report for the current cell. |
+| **`%lautoformat`** | Activates or deactivates automatic import sorting, formatting, and execution time display before every cell. |
+| **`%lcheck`** | Displays a linting report for the **entire saved notebook** (requires Google Drive mount). |
 
-After executing a cell magic command, the fixed/reported code is immediately executed (if applicable), maintaining the notebook workflow.
+After executing a cell magic command, the checked/formatted code is immediately executed (if applicable), maintaining the notebook workflow.
 
 ## Installation
 
@@ -31,18 +29,18 @@ pip install colablinter
 ```
 
 ## Usage
-The extension must be explicitly loaded in the notebook session before use. Once the extension is loaded, `%clautofix` is triggered automatically.
+The extension must be explicitly loaded in the notebook session before use. Once the extension is loaded, `%lautoformat` is activated by default.
 
 ```python
 %load_ext colablinter
 ```
 
 
-1. Fix and Format cell (`%%cfix`)
+1. Sorts imports and Formats cell (`%%cformat`)
 
-    `%%cfix` corrects code and runs the formatter. The cell executes the fixed code.
+    `%%cformat` corrects code and runs the formatter. The cell executes after cell is formatted.
     ```python
-    %%cfix
+    %%cformat
     import math, sys;
 
     class Example(   object ):
@@ -70,11 +68,11 @@ The extension must be explicitly loaded in the notebook session before use. Once
                 return (sys.path, some_string)
     ```
 
-2. Check cell quality (`%%creport`)
+2. Check cell quality (`%%ccheck`)
 
-    Use `%%creport` to see linting reports for the code below the command. After the report is displayed, the code in the cell executes as normal.
+    Use `%%ccheck` to see linting reports for the code below the command. After the report is displayed, the code in the cell executes as normal.
     ```python
-    %%creport
+    %%ccheck
 
     def invalid_code(x):
         return x + y # 'y' is not defined
@@ -95,23 +93,23 @@ The extension must be explicitly loaded in the notebook session before use. Once
     **Note on F401:**
     The linter is explicitly configured to **ignore F401 errors** (unused imports). This is to ensure compatibility with the stateful nature of Jupyter/Colab notebooks, where imports in one cell may be necessary for code execution in subsequent cells, preventing unintended breakage of the notebook's execution flow.
 
-3. Activate/Deactivate Auto Fix (`%clautofix`)
+3. Activate/Deactivate Auto Fix (`%lautoformat`)
 
-    The `%clautofix` line magic allows you to automatically fix code before every code cell is executed.
+    The `%lautoformat` line magic allows you to automatically fix code before every code cell is executed.
 
     To Activate Auto Fixing:
     ```python
-    %clautofix on # %clautofix off when you want to deactivate
+    %lautoformat on # %lautoformat off when you want to deactivate
     ```
 
-4. Check entire notebook (`%clreport`)
+4. Check entire notebook (`%lcheck`)
 
-    Use line magic `%clreport` to check across the entire saved notebook file (requires the notebook to be saved to Google Drive and mounted).
+    Use line magic `%lcheck` to check across the entire saved notebook file (requires the notebook to be saved to Google Drive and mounted).
 
     ```python
-    %clreport /content/drive/MyDrive/Colab Notebooks/path/to/notebook.ipynb
+    %lcheck /content/drive/MyDrive/Colab Notebooks/path/to/notebook.ipynb
     ```
 
 ## Known Caveats & Troubleshooting
 
-Magic Command Execution: When using magic or terminal commands with `%clautofix` on active, the autofix mechanism is temporarily suppressed during the final execution step to prevent infinite loops or dual checks. If you want to disable auto-fixing, use `%clautofix off`
+Magic Command Execution: When using magic or terminal commands while `%lautoformat` is active, the auto-format mechanism is temporarily suppressed during the final execution step to prevent infinite loops or dual checks. If you want to disable auto-formatting, use `%lautoformat off`

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "colablinter"
-version = "0.1.7"
+version = "0.2.0"
 description = "Linting and formatting Python code in Google Colab."
 readme = "README.md"
 authors = [

src/colablinter/__init__.py

@@ -8,7 +8,7 @@
     def load_ipython_extension(ipython: InteractiveShell):
         ipython.register_magics(ColabLinterMagics)
         logger.info("All commands registered.")
-        ipython.run_line_magic("clautofix", "on")
+        ipython.run_line_magic("lautoformat", "on")
 
 except Exception as e:
     logger.exception(f"Initialization failed: {e}")

src/colablinter/command.py

@@ -4,11 +4,13 @@
 
 _FILE_NAME = "notebook_cell.py"
 _RULESET = "F,E,I,B"
-_CELL_REPORT_COMMAND = f"ruff check --select {_RULESET} --ignore F401 --line-length 100 --stdin-filename={_FILE_NAME}"
-_CELL_CHECK_COMMAND = f"ruff check --select I --stdin-filename={_FILE_NAME} --fix"
+_CELL_CHECK_COMMAND = (
+    f"ruff check --select {_RULESET} --ignore F401,E501 --stdin-filename={_FILE_NAME}"
+)
+_CELL_CHECK_ISORT_COMMAND = f"ruff check --select I --stdin-filename={_FILE_NAME} --fix"
 _CELL_FORMAT_COMMAND = f"ruff format --stdin-filename={_FILE_NAME}"
 _NOTEBOOK_REPORT_COMMAND = (
-    f"ruff check --select {_RULESET} --line-length 100 '{{notebook_path}}'"
+    f"ruff check --select {_RULESET} --ignore E501 '{{notebook_path}}'"
 )
 
 
@@ -37,16 +39,16 @@ def execute_command(command: str, input_data: str) -> str | None:
         return None
 
 
-def cell_report(cell: str) -> None:
-    report = execute_command(_CELL_REPORT_COMMAND, input_data=cell)
+def cell_check(cell: str) -> None:
+    report = execute_command(_CELL_CHECK_COMMAND, input_data=cell)
     if report:
         logger.info(report)
     else:
         logger.info("No issues found. Code is clean.")
 
 
-def cell_check(cell: str) -> str | None:
-    fixed_code = execute_command(_CELL_CHECK_COMMAND, input_data=cell).strip()
+def cell_check_isort(cell: str) -> str | None:
+    fixed_code = execute_command(_CELL_CHECK_ISORT_COMMAND, input_data=cell).strip()
     if fixed_code.strip():
         return fixed_code.strip()
     return None

src/colablinter/magics.py

@@ -1,12 +1,13 @@
 import os
+import time
 
-from IPython.core.interactiveshell import ExecutionInfo
+from IPython.core.interactiveshell import ExecutionInfo, ExecutionResult
 from IPython.core.magic import Magics, cell_magic, line_magic, magics_class
 
 from colablinter.command import (
     cell_check,
+    cell_check_isort,
     cell_format,
-    cell_report,
     notebook_report,
 )
 from colablinter.logger import logger
@@ -36,61 +37,73 @@ def _ensure_drive_mounted():
         ) from e
 
 
+class CellTimer:
+    def __init__(self):
+        self.start_time = None
+
+    def start(self, info: ExecutionInfo | None = None):
+        self.start_time = time.perf_counter()
+
+    def stop(self, result: ExecutionResult | None = None):
+        if self.start_time:
+            duration = time.perf_counter() - self.start_time
+            logger.info(f"\033[92m✔ Done | {duration:.3f}s\033[0m")
+            self.start_time = None
+
+
 @magics_class
 class ColabLinterMagics(Magics):
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
-        self._is_autofix_active = False
+        self._is_autoformat_active = True
+        self.timer = CellTimer()
 
     @cell_magic
-    def creport(self, line: str, cell: str) -> None:
+    def ccheck(self, line: str, cell: str) -> None:
         stripped_cell = cell.strip()
-        cell_report(stripped_cell)
+        cell_check(stripped_cell)
         self.__execute(stripped_cell)
 
     @cell_magic
-    def cfix(self, line: str, cell: str) -> None:
+    def cformat(self, line: str, cell: str) -> None:
         stripped_cell = cell.strip()
         if _is_invalid_cell(stripped_cell):
             logger.info(
-                "Fix skipped. Cell starts with magic (%, %%) or shell (!...) command."
+                "Format skipped. Cell starts with magic (%, %%) or shell (!...) command."
             )
             self.__execute(stripped_cell)
             return None
 
-        fixed_code = cell_check(stripped_cell)
-        if fixed_code is None:
-            logger.error("Linter check failed. Code not modified.")
+        formatted_code = cell_format(stripped_cell)
+        if formatted_code is None:
+            logger.error("Formatter failed. Code not modified.")
             self.__execute(stripped_cell)
             return None
 
-        formatted_code = cell_format(fixed_code)
-        if formatted_code:
-            self.shell.set_next_input(formatted_code, replace=True)
-            self.__execute(formatted_code)
-        else:
-            logger.error("Formatter failed. Check-fixed code executed.")
+        fixed_code = cell_check_isort(formatted_code)
+        if fixed_code:
+            self.shell.set_next_input(fixed_code, replace=True)
             self.__execute(fixed_code)
+        else:
+            logger.error("Formatter failed. Formatted code executed.")
+            self.__execute(formatted_code)
 
     @line_magic
-    def clautofix(self, line: str) -> None:
+    def lautoformat(self, line: str) -> None:
         action = line.strip().lower()
         if action == "on":
-            self.shell.events.register("pre_run_cell", self.__autofix)
-            self._is_autofix_active = True
-            logger.info("Auto-fix activated for pre-run cells.")
+            self.__register()
+            self._is_autoformat_active = True
+            logger.info("Auto-format activated for pre-run cells.")
         elif action == "off":
-            try:
-                self.shell.events.unregister("pre_run_cell", self.__autofix)
-            except Exception:
-                pass
-            self._is_autofix_active = False
-            logger.info("Auto-fix deactivated.")
+            self.__unregister()
+            self._is_autoformat_active = False
+            logger.info("Auto-format deactivated.")
         else:
-            logger.info("Usage: %clautofix on or %clautofix off.")
+            logger.info("Usage: %lautoformat on or %lautoformat off.")
 
     @line_magic
-    def clreport(self, line: str) -> None:
+    def lcheck(self, line: str) -> None:
         _ensure_drive_mounted()
         notebook_path = line.strip().strip("'").strip('"')
         if not notebook_path:
@@ -113,40 +126,56 @@ def clreport(self, line: str) -> None:
         logger.info("-------------------------------------------------------------")
 
     def __execute(self, cell: str) -> None:
-        if self._is_autofix_active:
+        if self._is_autoformat_active:
             logger.info(
-                "Autofix is temporarily suppressed to prevent dual execution. "
-                "To disable, run: %clautofix off"
+                "autoformat is temporarily suppressed to prevent dual execution. "
+                "To disable, run: %lautoformat off"
             )
-            try:
-                self.shell.events.unregister("pre_run_cell", self.__autofix)
-            except ValueError:
-                pass
+            self.__unregister()
         try:
             self.shell.run_cell(cell, silent=False, store_history=True)
         except Exception as e:
             logger.exception(f"Code execution failed: {e}")
         finally:
-            if self._is_autofix_active:
-                try:
-                    self.shell.events.register("pre_run_cell", self.__autofix)
-                except Exception:
-                    pass
+            if self._is_autoformat_active:
+                self.__register()
 
-    def __autofix(self, info: ExecutionInfo) -> None:
+    def __autoformat(self, info: ExecutionInfo) -> None:
         stripped_cell = info.raw_cell.strip()
         if _is_invalid_cell(stripped_cell):
-            logger.info("Autofix is skipped for cell with magic or terminal.")
+            logger.info("autoformat is skipped for cell with magic or terminal.")
             return None
 
-        fixed_code = cell_check(stripped_cell)
-        if fixed_code is None:
-            logger.error("Linter check failed during auto-fix.")
+        formatted_code = cell_format(stripped_cell)
+        if formatted_code is None:
+            logger.error("Formatter failed during auto-format.")
             return None
 
-        formatted_code = cell_format(fixed_code)
-        if formatted_code is None:
-            logger.error("Formatter failed during auto-fix.")
+        fixed_code = cell_check_isort(formatted_code)
+        if fixed_code is None:
+            logger.error("Linter check failed during auto-format.")
             return None
 
-        self.shell.set_next_input(formatted_code, replace=True)
+        self.shell.set_next_input(fixed_code, replace=True)
+
+    def __register(self) -> None:
+        for event, callback in [
+            ("pre_run_cell", self.__autoformat),
+            ("pre_run_cell", self.timer.start),
+            ("post_run_cell", self.timer.stop),
+        ]:
+            try:
+                self.shell.events.register(event, callback)
+            except Exception:
+                pass
+
+    def __unregister(self) -> None:
+        for event, callback in [
+            ("pre_run_cell", self.__autoformat),
+            ("pre_run_cell", self.timer.start),
+            ("post_run_cell", self.timer.stop),
+        ]:
+            try:
+                self.shell.events.unregister(event, callback)
+            except Exception:
+                pass