progress-table 3.2.1__tar.gz → 3.3.0__tar.gz

{progress_table-3.2.1 → progress_table-3.3.0}/.gitignore

@@ -1,4 +1,6 @@
 .idea
+.vscode
+.zed
 .ipynb_checkpoints
 *.ipynb
 __pycache__

{progress_table-3.2.1 → progress_table-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: progress-table
-Version: 3.2.1
+Version: 3.3.0
 Summary: Display progress as a pretty table in the command line.
 Project-URL: Home, https://github.com/gahaalt/progress-table
 Project-URL: Documentation, https://github.com/sjmikler/progress-table/blob/main/docs
@@ -40,6 +40,7 @@ Lightweight utility to display the progress of your process as a pretty table in
 * Designed to monitor ML experiments, but works for any metrics-producing process
 * Allows you to see at a glance what's going on with your process
 * Increases readability and simplifies your command line logging
+* Is efficient: redraws only the modified rows
 
 ### Change this:
 
@@ -117,15 +118,15 @@ Go to [advanced usage](https://github.com/sjmikler/progress-table/blob/main/docs
 
 ## Troubleshooting
 
-### Exceesive output
+### Excessive output
 
 Progress Table works correctly in most consoles, but there are some exceptions:
 
-* Some cloud logging consoles (e.g. kubernetes) don't support `\r` properly. You can still use ProgressTable, but with `interactive=0` option. This mode will not display progress bars.
+* Some cloud logging consoles (e.g. Kubernetes) do not handle live, carriage-return-based redraws properly. You can still use ProgressTable with `interactive=0`. This mode prints rows when they are finalized and does not display progress bars.
 
-* Some consoles like 'PyCharm Python Console' or 'IDLE' don't support cursor movement. You can still use ProgressTable, but with `interactive=1` option. In this mode, you can display only a single progress bar.
+* Some consoles, such as the PyCharm Python Console or IDLE, do not support moving the cursor to previous lines. You can still use ProgressTable with `interactive=1`. This mode can redraw the current line and display one progress-bar position, but previous rows remain visually frozen.
 
-> By default `interactive=2`. You can change the default 'interactive' with an argument when creating the table object or by setting 'PTABLE_INTERACTIVE' environment variable, e.g. `PTABLE_INTERACTIVE=1`.
+> When `interactive` is omitted, it defaults to `1` in Jupyter, `0` when output is redirected, and `2` in an interactive terminal. Set it explicitly when creating the table, or override the automatic default with the `PTABLE_INTERACTIVE` environment variable, for example `PTABLE_INTERACTIVE=1`.
 
 ### Other problems
 

{progress_table-3.2.1 → progress_table-3.3.0}/README.md

@@ -10,6 +10,7 @@ Lightweight utility to display the progress of your process as a pretty table in
 * Designed to monitor ML experiments, but works for any metrics-producing process
 * Allows you to see at a glance what's going on with your process
 * Increases readability and simplifies your command line logging
+* Is efficient: redraws only the modified rows
 
 ### Change this:
 
@@ -87,15 +88,15 @@ Go to [advanced usage](docs/advanced-usage.md) page for more information.
 
 ## Troubleshooting
 
-### Exceesive output
+### Excessive output
 
 Progress Table works correctly in most consoles, but there are some exceptions:
 
-* Some cloud logging consoles (e.g. kubernetes) don't support `\r` properly. You can still use ProgressTable, but with `interactive=0` option. This mode will not display progress bars.
+* Some cloud logging consoles (e.g. Kubernetes) do not handle live, carriage-return-based redraws properly. You can still use ProgressTable with `interactive=0`. This mode prints rows when they are finalized and does not display progress bars.
 
-* Some consoles like 'PyCharm Python Console' or 'IDLE' don't support cursor movement. You can still use ProgressTable, but with `interactive=1` option. In this mode, you can display only a single progress bar.
+* Some consoles, such as the PyCharm Python Console or IDLE, do not support moving the cursor to previous lines. You can still use ProgressTable with `interactive=1`. This mode can redraw the current line and display one progress-bar position, but previous rows remain visually frozen.
 
-> By default `interactive=2`. You can change the default 'interactive' with an argument when creating the table object or by setting 'PTABLE_INTERACTIVE' environment variable, e.g. `PTABLE_INTERACTIVE=1`.
+> When `interactive` is omitted, it defaults to `1` in Jupyter, `0` when output is redirected, and `2` in an interactive terminal. Set it explicitly when creating the table, or override the automatic default with the `PTABLE_INTERACTIVE` environment variable, for example `PTABLE_INTERACTIVE=1`.
 
 ### Other problems
 

{progress_table-3.2.1 → progress_table-3.3.0}/README_pypi.md

@@ -10,6 +10,7 @@ Lightweight utility to display the progress of your process as a pretty table in
 * Designed to monitor ML experiments, but works for any metrics-producing process
 * Allows you to see at a glance what's going on with your process
 * Increases readability and simplifies your command line logging
+* Is efficient: redraws only the modified rows
 
 ### Change this:
 
@@ -87,15 +88,15 @@ Go to [advanced usage](https://github.com/sjmikler/progress-table/blob/main/docs
 
 ## Troubleshooting
 
-### Exceesive output
+### Excessive output
 
 Progress Table works correctly in most consoles, but there are some exceptions:
 
-* Some cloud logging consoles (e.g. kubernetes) don't support `\r` properly. You can still use ProgressTable, but with `interactive=0` option. This mode will not display progress bars.
+* Some cloud logging consoles (e.g. Kubernetes) do not handle live, carriage-return-based redraws properly. You can still use ProgressTable with `interactive=0`. This mode prints rows when they are finalized and does not display progress bars.
 
-* Some consoles like 'PyCharm Python Console' or 'IDLE' don't support cursor movement. You can still use ProgressTable, but with `interactive=1` option. In this mode, you can display only a single progress bar.
+* Some consoles, such as the PyCharm Python Console or IDLE, do not support moving the cursor to previous lines. You can still use ProgressTable with `interactive=1`. This mode can redraw the current line and display one progress-bar position, but previous rows remain visually frozen.
 
-> By default `interactive=2`. You can change the default 'interactive' with an argument when creating the table object or by setting 'PTABLE_INTERACTIVE' environment variable, e.g. `PTABLE_INTERACTIVE=1`.
+> When `interactive` is omitted, it defaults to `1` in Jupyter, `0` when output is redirected, and `2` in an interactive terminal. Set it explicitly when creating the table, or override the automatic default with the `PTABLE_INTERACTIVE` environment variable, for example `PTABLE_INTERACTIVE=1`.
 
 ### Other problems
 

{progress_table-3.2.1 → progress_table-3.3.0}/docs/advanced-usage.md

@@ -2,12 +2,12 @@
 
 ## Indexing
 
-Progress Table with `interactive>=2` supports modyfing already closed rows (rows above the current row).
-This can be done either with `.update` method or using `.at` indexing which is a shorthand for `AtIndexer` object.
+Progress Table with `interactive>=2` supports modifying already closed rows (rows above the current row).
+This can be done either with the `.update` method or with `.at` indexing, which is shorthand for the `AtIndexer`
+object.
 
 
-> When using `interactive<2` mode, you can only modify the current row.
-> Any changes made to other rows will not be displayed.
+> With `interactive<2`, only the current row can be redrawn. Changes to other rows are stored but are not displayed.
 
 ### `.update` method
 
@@ -79,9 +79,10 @@ Which should give you the following:
 There are two types of progress bars in Progress Table: embedded and non-embedded.
 
 
-> When using `interactive=0` mode, the progress bars will not be displayed.
+> With `interactive=0`, live redraws are disabled, rows are printed when finalized, and progress bars are not
+> displayed.
 
-> When using `interactive=1` mode, progress bars are be displayed only in the bottom row.
+> With `interactive=1`, only the current line can be redrawn, so only one progress-bar position is visible.
 
 ### Embedded progress bars
 

{progress_table-3.2.1 → progress_table-3.3.0}/progress_table/__init__.py

@@ -10,7 +10,7 @@ Supported features:
 """
 
 __license__ = "MIT"
-__version__ = "3.2.1"
+__version__ = "3.3.0"
 __author__ = "Szymon Mikler"
 
 from progress_table.progress_table import ProgressTable, styles

{progress_table-3.2.1 → progress_table-3.3.0}/progress_table/common.py

@@ -3,7 +3,9 @@
 
 """Common utilities for progress_table."""
 
-from typing import Union
+import os
+import sys
+from typing import Optional, TextIO, Union
 
 from colorama import Back, Fore, Style
 
@@ -49,3 +51,26 @@ def maybe_convert_to_colorama(color: ColorFormat) -> str:
         color = color.split(" ")
     results = [maybe_convert_to_colorama_str(x) for x in color]
     return "".join(results)
+
+
+def is_ipython_kernel() -> bool:
+    try:
+        from IPython.core.getipython import get_ipython
+
+        ipython = get_ipython()
+        if ipython is not None:
+            return "IPKernelApp" in ipython.config
+        return False
+    except ImportError:
+        return False
+
+
+def is_interactive_terminal(stream: Optional[TextIO] = None) -> bool:
+    """Check whether a stream supports interactive terminal output."""
+    if stream is None:
+        stream = sys.stdout
+        assert stream is not None
+    try:
+        return stream.isatty() and os.environ.get("TERM") != "dumb"
+    except (AttributeError, OSError, ValueError):
+        return False

{progress_table-3.2.1 → progress_table-3.3.0}/progress_table/progress_table.py

@@ -25,6 +25,8 @@ from progress_table.common import (
     CURSOR_UP,
     ColorFormat,
     ColorFormatTuple,
+    is_interactive_terminal,
+    is_ipython_kernel,
     maybe_convert_to_colorama,
 )
 
@@ -133,7 +135,7 @@ class ProgressTable:
         self,
         *cols: str,
         columns: Iterable[str] = (),
-        interactive: int = int(os.environ.get("PTABLE_INTERACTIVE", "2")),
+        interactive: int | None = None,
         refresh_rate: int = 20,
         num_decimal_places: int = 4,
         default_column_width: int | None = None,
@@ -148,7 +150,7 @@ class ProgressTable:
         pbar_show_eta: bool = False,
         pbar_embedded: bool = True,
         pbar_style: str | styles.PbarStyleBase = "square",
-        pbar_style_embed: str | styles.PbarStyleBase = "cdots",
+        pbar_style_embed: str | styles.PbarStyleBase = "dash",
         print_header_on_top: bool = True,
         print_header_every_n_rows: int = 30,
         custom_cell_format: Callable[[Any], str] | None = None,
@@ -177,15 +179,16 @@ class ProgressTable:
                   settings like alignment, color and width, while columns added through methods can have those
                   customized.
             columns: Alias for `cols`.
-            interactive: Three interactivity levels are available: 2, 1 and 0. It's recommended to use 2, but some
-                         terminal environments might not all features. When using decreased interactivity, some features
-                         will be supressed. If something doesn't look right in your terminal, try to decrease the
-                         interactivity.
-                         On level 2 you can modify all rows, including the rows above the current one.
-                         You can also add columns on-the-fly or reorder them. You can use nested progress bars.
-                         On level 1 you can only operate on the current row, the old rows are frozen, but you still get
-                         to use a progress bar, albeit not nested. On level 0 there are no progress bars and rows are
-                         only printed after calling `next_row`.
+            interactive: Three interactivity levels are available: 2, 1 and 0. Level 2 is recommended, but some
+                         environments do not support all of its features. If the output does not look right, try a
+                         lower level. When omitted, this defaults to level 1 in Jupyter, level 0 when output is
+                         redirected, and level 2 in an interactive terminal. The `PTABLE_INTERACTIVE` environment
+                         variable can override this automatic default.
+                         Level 2 supports redrawing any displayed row, adding or reordering columns on the fly, and
+                         nested progress bars. Level 1 redraws only the current line; changes to previous rows are
+                         stored but not displayed, and only one progress-bar position is visible. Level 0 disables
+                         live redraws and progress bars; rows are displayed when finalized with methods such as
+                         `next_row` or `add_row`.
             refresh_rate: The maximal number of times per second to render the updates in the table.
             num_decimal_places: This is only applicable when using the default formatting. This won't be used if
                                 `custom_cell_repr` is set. If applicable, for every displayed value except integers
@@ -292,7 +295,26 @@ class ProgressTable:
         self._CURSOR_ROW = 0
 
         # Interactivity settings
-        self.interactive = interactive
+        auto_detected: bool = False
+
+        if interactive is not None:
+            self.interactive = interactive
+        elif "PTABLE_INTERACTIVE" in os.environ:
+            self.interactive = int(os.environ.get("PTABLE_INTERACTIVE", ""))
+        elif is_ipython_kernel():
+            auto_detected = True
+            self.interactive = 1
+        elif not all(is_interactive_terminal(stream) for stream in self.files):
+            auto_detected = True
+            self.interactive = 0
+        else:
+            self.interactive = 2
+
+        if auto_detected:
+            logger.warning(
+                f"Automatically deduced `interactive` as {self.interactive} for compatibility."
+                " Set `interactive` explicitly to hide the warning."
+            )
         assert self.interactive in (2, 1, 0)
 
         self._printing_buffer: list[str] = []
@@ -413,6 +435,10 @@ class ProgressTable:
                          If column already exists, they will have no effect.
 
         """
+        if self._closed:
+            msg = "Table was closed! Updating closed tables is not supported."
+            raise TableClosedError(msg)
+
         if name not in self.column_names:
             self.add_column(name, **column_kwds)
 
@@ -1290,19 +1316,22 @@ class TableAtIndexer:
             self.edit_mode_prefix_map.update({word[:i].lower(): word for i in range(1, len(word) + 1)})
             self.edit_mode_prefix_map.update({word[:i].upper(): word for i in range(1, len(word) + 1)})
 
-    def _parse_index(self, key: slice | tuple) -> tuple:
+    def _parse_index(self, key: slice | tuple) -> tuple[list[int], list[str], str]:
+        rows: slice | int
+        cols: slice | int
+        mode: str
         if isinstance(key, slice):
-            rows: slice | int = key
-            cols: slice | int = slice(None)
-            mode: str = "values"
+            rows = key
+            cols = slice(None)
+            mode = "values"
         elif len(key) == 2:
-            rows: slice | int = key[0]
-            cols: slice | int = key[1]
-            mode: str = "values"
+            rows = key[0]
+            cols = key[1]
+            mode = "values"
         elif len(key) >= 3:
-            rows: slice | int = key[0]
-            cols: slice | int = key[1]
-            mode: str = key[2]
+            rows = key[0]
+            cols = key[1]
+            mode = key[2]
             assert mode in self.edit_mode_prefix_map, f"Unknown mode `{mode}`. Available: values, weights, colors"
             mode = self.edit_mode_prefix_map[mode]
         else: