progress-table 1.3.0__tar.gz → 1.3.2__tar.gz

{progress-table-1.3.0 → progress-table-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: progress-table
-Version: 1.3.0
+Version: 1.3.2
 Summary: Display progress as a pretty table in the command line.
 Home-page: https://github.com/gahaalt/progress-table.git
 Author: Szymon Mikler

{progress-table-1.3.0 → progress-table-1.3.2}/progress_table/__init__.py

@@ -1,6 +1,6 @@
 #  Copyright (c) 2022-2024 Szymon Mikler
 
-__version__ = "1.3.0"
+__version__ = "1.3.2"
 
 from progress_table.v0.progress_table import ProgressTableV0
 from progress_table.v1.progress_table import ProgressTableV1

{progress-table-1.3.0 → progress-table-1.3.2}/progress_table/v0/progress_table.py

@@ -27,6 +27,8 @@ ALL_COLORS_STYLES = ALL_COLORS + ALL_STYLES
 ITERATOR_LENGTH_UNKNOWN_WARNED_ONCE = False
 ITERATOR_LENGTH_CACHE: Dict[int, int] = {}
 
+DEPRECATION_PRINTED = False
+
 
 class ProgressTableV0:
     def __init__(
@@ -82,6 +84,12 @@ class ProgressTableV0:
             file: Redirect the output to another stream. There can be multiple streams at once passed as
                   a list or a tuple. Defaults to sys.stdout.
         """
+        global DEPRECATION_PRINTED
+
+        if not DEPRECATION_PRINTED:
+            logging.warning("ProgressTableV0 is deprecated, use ProgressTableV1 instead")
+            DEPRECATION_PRINTED = True
+
         self.refresh_rate = refresh_rate
         self.default_width = default_column_width
         self.default_alignment = default_column_alignment

{progress-table-1.3.0 → progress-table-1.3.2}/progress_table/v1/progress_table.py

@@ -219,7 +219,7 @@ class ProgressTableV1:
         self.finished_rows: list[dict[str, Any]] = []
 
         self._new_row: dict[str, Any] = {}
-        self.new_row_cumulated_weight: dict[str, int] = {}
+        self._new_row_cumulated_weight: dict[str, int] = {}
         self.files = (file,) if not isinstance(file, (list, tuple)) else file
 
         self.previous_header_counter = 0
@@ -288,27 +288,35 @@ class ProgressTableV1:
         # Initialize color for the column in the new row
         self._prepare_row_color_dict()
 
-    def add_columns(self, iterable, **kwds):
+    def add_columns(self, *columns, **kwds):
         """Add multiple columns to the table."""
-        for column in iterable:
+        for column in columns:
             self.add_column(column, **kwds)
 
-    def update(self, key, value, *, weight=1):
-        """Update value in the current row."""
+    def update(self, key, value, *, weight=1, **column_kwds):
+        """Update value in the current row. This is extends capabilities of __setitem__.
+
+        Args:
+            key: Name of the column.
+            value: Value to be set.
+            weight: Weight of the value. This is used for aggregation.
+            column_kwds: Additional arguments for the column. They will be only used for column creation.
+                         If column already exists, they will have no effect.
+        """
         if key not in self.column_names:
             if self._is_table_opened:
                 logging.info("Closing table (new column added to opened table)")
-                self.close(close_pbars=False)
+                self.close(close_pbars=False, close_row=False)
 
-            self.add_column(key)
+            self.add_column(key, **column_kwds)
 
         # Set default values for new rows
         self._new_row.setdefault(key, 0)
-        self.new_row_cumulated_weight.setdefault(key, 0)
+        self._new_row_cumulated_weight.setdefault(key, 0)
 
         fn = self.column_aggregates[key]
-        self._new_row[key] = fn(value, self._new_row[key], self.new_row_cumulated_weight[key])
-        self.new_row_cumulated_weight[key] += weight
+        self._new_row[key] = fn(value, self._new_row[key], self._new_row_cumulated_weight[key])
+        self._new_row_cumulated_weight[key] += weight
 
         t0 = time.time()
         td = t0 - self._last_time_row_printed
@@ -335,7 +343,7 @@ class ProgressTableV1:
             return
 
         logging.info("Closing table (reordering columns)")
-        self.close(close_pbars=False)
+        self.close(close_pbars=False, close_row=False)
 
         assert isinstance(column_names, (List, Tuple))
         assert all([x in self.column_names for x in column_names]), f"Columns {column_names} not in {self.column_names}"
@@ -444,7 +452,8 @@ class ProgressTableV1:
 
     def _display_new_row_or_pbar(self):
         if self._active_pbars.get(0, None) is not None:
-            self._active_pbars[0].display()  # Level 0 pbar is embedded into the row, if it exists we want to display it instead of a row
+            # Level 0 pbar is embedded into the row, if it exists we want to display it instead of a row
+            self._active_pbars[0].display()
         else:
             self._display_new_row()
 
@@ -466,6 +475,9 @@ class ProgressTableV1:
         if split or self._request_splitter:
             self._print_splitter()
 
+        # Reset aggregated values!
+        self._new_row_cumulated_weight = {}
+
         self._prepare_row_color_dict(color)
         self._display_new_row()
         self._print()  # Insert a newline
@@ -548,6 +560,7 @@ class ProgressTableV1:
         level=None,
         total=None,
         refresh_rate=None,
+        description="",
         show_throughput=None,
         show_progress=None,
     ):
@@ -559,6 +572,7 @@ class ProgressTableV1:
             level: Level of the progress bar. If not provided, it will be set automatically.
             total: Total number of iterations. If not provided, it will be calculated from the length of the iterable.
             refresh_rate: The maximal number of times per second the progress bar will be refreshed.
+            description: Custom description of the progress bar that will be shown as prefix.
             show_throughput: If True, the throughput will be displayed.
             show_progress: If True, the progress will be displayed.
         """
@@ -574,6 +588,7 @@ class ProgressTableV1:
             total=total,
             level=level,
             refresh_rate=refresh_rate if refresh_rate is not None else self.refresh_rate,
+            description=description,
             show_throughput=show_throughput if show_throughput is not None else self.pbar_show_throughput,
             show_progress=show_progress if show_progress is not None else self.pbar_show_progress,
         )
@@ -589,7 +604,7 @@ class ProgressTableV1:
 
 
 class TableProgressBar:
-    def __init__(self, iterable, *, table, total, level, refresh_rate, show_throughput, show_progress):
+    def __init__(self, iterable, *, table, total, level, refresh_rate, description, show_throughput, show_progress):
         self.iterable: Iterable | None = iterable
 
         self._step: int = 0
@@ -600,6 +615,7 @@ class TableProgressBar:
         self.level: int = level
         self.table: ProgressTableV1 = table
         self.refresh_rate: int = refresh_rate
+        self.description: str = description
         self.show_progress: bool = show_progress
         self.show_throughput: bool = show_throughput
         self._is_active: bool = True
@@ -618,13 +634,15 @@ class TableProgressBar:
         throughput = self._step / time_passed if time_passed > 0 else 0.0
 
         inside_infobar = []
-        if self.show_throughput:
-            inside_infobar.append(f"{throughput: <.2f} it/s")
+        if self.description:
+            inside_infobar.append(self.description)
         if self.show_progress:
             if self._total:
                 inside_infobar.append(f"{self._step}/{self._total}")
             else:
                 inside_infobar.append(f"{self._step}")
+        if self.show_throughput:
+            inside_infobar.append(f"{throughput: <.2f} it/s")
         infobar = "[" + ", ".join(inside_infobar) + "] " if inside_infobar else ""
 
         pbar = ["\n" * self.level]

{progress-table-1.3.0 → progress-table-1.3.2}/progress_table.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: progress-table
-Version: 1.3.0
+Version: 1.3.2
 Summary: Display progress as a pretty table in the command line.
 Home-page: https://github.com/gahaalt/progress-table.git
 Author: Szymon Mikler

{progress-table-1.3.0 → progress-table-1.3.2}/progress_table.egg-info/SOURCES.txt

@@ -15,4 +15,6 @@ progress_table/v0/progress_table.py
 progress_table/v0/symbols.py
 progress_table/v1/__init__.py
 progress_table/v1/progress_table.py
-progress_table/v1/styles.py
+progress_table/v1/styles.py
+tests/test_docs_automated.py
+tests/test_examples_automated.py

progress-table-1.3.2/tests/test_docs_automated.py

@@ -0,0 +1,61 @@
+#  Copyright (c) 2022-2024 Szymon Mikler
+
+import logging
+import os
+import pathlib
+import re
+
+
+def get_header(msg):
+    msg_len = len(msg)
+    header = [
+        "#" * (msg_len + 6),
+        "## " + msg + " ##",
+        "#" * (msg_len + 6),
+    ]
+    return "\n".join(header) + "\n"
+
+
+def scan_for_code_blobs(text):
+    # Capture code blocks starting with py or python
+    blobs = re.findall(r"```(py|python)\n([\s\S]+?)\n```", text)
+
+    new_blobs = []
+    for mode, blob in blobs:
+        if "..." in blob:
+            continue
+        header = get_header(f"Generated ({mode})")
+        blob = header + blob
+
+        # For `py` code blocks, we append them to previous existing block
+        # But `python` block starts a new scope and finishes the previous block
+        # They usually need to include imports
+        if mode == "py" and new_blobs:
+            new_blobs[-1] = new_blobs[-1] + "\n" + blob
+        else:
+            new_blobs.append(blob)
+    return new_blobs
+
+
+def test_all_code_blobs():
+    # Testing whether code blobs from the documentation run without errors
+    all_code_blobs = []
+
+    for root, dirs, files in os.walk(""):
+        for file in files:
+            path = pathlib.Path(os.path.join(root, file))
+            if path.suffix == ".md":
+                code_blobs = scan_for_code_blobs(path.open("r").read())
+                for blob in code_blobs:
+                    all_code_blobs.append(blob)
+
+    logging.warning(f"Detected {len(all_code_blobs)} code examples!")
+
+    for idx, blob in enumerate(all_code_blobs):
+        try:
+            globals_temp = {}
+            exec(blob, globals_temp)
+        except Exception as e:
+            print(f"Exception during automated documentation testing {idx}/{len(all_code_blobs)}:")
+            print(blob)
+            raise e

progress-table-1.3.2/tests/test_examples_automated.py

@@ -0,0 +1,63 @@
+#  Copyright (c) 2022-2024 Szymon Mikler
+
+import hashlib
+import importlib
+import random
+import sys
+from glob import glob
+from io import StringIO
+
+EXPECTED_OUTPUTS = {
+    "examples.nn_training": "7e50cfd539e3e1799ecd5a7e7b7a7e18",
+    "examples.cumulating": "b5b7bc9b8232545ebfd5ca777bddacb4",
+    "examples.fibonacci": "bae5411af4bf8a4326f1bce59ca9aad9",
+    "examples.features": "474d4aff94a3070d2300d78d4159e0a6",
+}
+
+
+def set_seed():
+    random.seed(42)
+
+
+def capture_example_stdout(main_fn):
+    # To eliminate run to run variation of the example outputs we need to be independent from the execution speed
+    # This includes removing the influence of:
+    # * refresh rate
+    # * throughput display
+    override_kwds = dict(
+        refresh_rate=1000000000,
+        pbar_show_throughput=False,
+    )
+
+    # We will replace stdout with custom StringIO and check whether example stdout is as expected
+    out_buffer = StringIO()
+    sys.stdout = out_buffer
+    set_seed()
+    main_fn(**override_kwds)
+    sys.stdout = sys.__stdout__
+    return out_buffer.getvalue()
+
+
+def test_all_examples():
+    # Testing whether examples run exactly as intended
+
+    outputs = {}
+    for module in glob("examples/*"):
+        module = module.replace(".py", "").replace("/", ".")
+        print(f"Running example: {module}")
+        main_fn = importlib.import_module(module).main
+        out_str = capture_example_stdout(main_fn)
+
+        md5hash = hashlib.md5(out_str.encode()).hexdigest()
+        outputs[module] = md5hash
+
+    err_msg = []
+    for key in EXPECTED_OUTPUTS:
+        output = outputs.get(key, None)
+        expected = EXPECTED_OUTPUTS[key]
+        if output != expected:
+            err_msg.append(f" {output} instead of {expected} in {key}")
+    err_msg = "\n".join(err_msg)
+
+    if err_msg:
+        assert False, f"Errors in example outputs\n{err_msg}"