progress-table 3.0.2__tar.gz → 3.1.1__tar.gz

{progress_table-3.0.2 → progress_table-3.1.1}/.gitignore

@@ -4,6 +4,10 @@
 __pycache__
 *.egg-info
 
+.coverage
+coverage.xml
+README_pypi.md
+
 devel/
 dist
 build

{progress_table-3.0.2 → progress_table-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: progress-table
-Version: 3.0.2
+Version: 3.1.1
 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
@@ -34,7 +34,8 @@ Description-Content-Type: text/markdown
 # Progress Table
 
 [![PyPi version](https://img.shields.io/badge/dynamic/json?label=latest&query=info.version&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fprogress-table%2Fjson)](https://pypi.org/project/progress-table)
-[![PyPI license](https://img.shields.io/badge/dynamic/json?label=license&query=info.license&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fprogress-table%2Fjson)](https://pypi.org/project/progress-table)
+[![PyPI license](https://img.shields.io/badge/dynamic/json?label=license&query=info.license&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fprogress-table%2Fjson)](https://github.com/sjmikler/progress-table/blob/main/LICENSE.txt)
+[![codecov](https://codecov.io/gh/sjmikler/progress-table/graph/badge.svg?token=CDJKF0FFAQ)](https://codecov.io/gh/sjmikler/progress-table)
 
 Lightweight utility to display the progress of your process as a pretty table in the command line.
 

{progress_table-3.0.2 → progress_table-3.1.1}/README.md

@@ -7,7 +7,8 @@
 # Progress Table
 
 [![PyPi version](https://img.shields.io/badge/dynamic/json?label=latest&query=info.version&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fprogress-table%2Fjson)](https://pypi.org/project/progress-table)
-[![PyPI license](https://img.shields.io/badge/dynamic/json?label=license&query=info.license&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fprogress-table%2Fjson)](https://pypi.org/project/progress-table)
+[![PyPI license](https://img.shields.io/badge/dynamic/json?label=license&query=info.license&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fprogress-table%2Fjson)](https://github.com/sjmikler/progress-table/blob/main/LICENSE.txt)
+[![codecov](https://codecov.io/gh/sjmikler/progress-table/graph/badge.svg?token=CDJKF0FFAQ)](https://codecov.io/gh/sjmikler/progress-table)
 
 Lightweight utility to display the progress of your process as a pretty table in the command line.
 

{progress_table-3.0.2 → progress_table-3.1.1}/README_pypi.md

@@ -7,7 +7,8 @@
 # Progress Table
 
 [![PyPi version](https://img.shields.io/badge/dynamic/json?label=latest&query=info.version&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fprogress-table%2Fjson)](https://pypi.org/project/progress-table)
-[![PyPI license](https://img.shields.io/badge/dynamic/json?label=license&query=info.license&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fprogress-table%2Fjson)](https://pypi.org/project/progress-table)
+[![PyPI license](https://img.shields.io/badge/dynamic/json?label=license&query=info.license&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fprogress-table%2Fjson)](https://github.com/sjmikler/progress-table/blob/main/LICENSE.txt)
+[![codecov](https://codecov.io/gh/sjmikler/progress-table/graph/badge.svg?token=CDJKF0FFAQ)](https://codecov.io/gh/sjmikler/progress-table)
 
 Lightweight utility to display the progress of your process as a pretty table in the command line.
 

progress_table-3.1.1/docs/advanced-usage.md

@@ -0,0 +1,290 @@
+# Advanced usage
+
+## 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.
+
+
+> When using `interactive<2` mode, you can only modify the current row.
+> Any changes made to other rows will not be displayed.
+
+### `.update` method
+
+When using `.update` method you update one value at once.
+Use column name and row index to specify the cell location.
+Example of using `.update` method:
+
+```python
+from progress_table import ProgressTable
+
+table = ProgressTable()
+table.add_column("Value")
+table.add_rows(3)  # Adding empty rows
+
+table.update(name="Value", value=1.0, row=1)
+table.update(name="Value", value=2.0, row=0, cell_color="red bold")
+table.update(name="Value", value=3.0, row=2)  # modify last-but-one row
+table.close()
+```
+
+Which might give you the following:
+
+```output
+╭──────────╮
+│  Value   │
+├──────────┤
+│  2.0000  │
+│  1.0000  │
+│  3.0000  │
+╰──────────╯
+```
+
+### `.at` indexing
+
+When using `.at` indexing you do not use column names, instead you use column indices.
+First column has index 0, second 1, etc. Slicing operations are also supported with `.at` indexing.
+Treat the table similarly to a numpy array:
+
+```python
+from progress_table import ProgressTable
+
+table = ProgressTable()
+table.add_columns(4)  # Add more columns with automatic names
+table.add_rows(4)  # Adding empty rows
+
+table.at[:] = 0.0  # Initialize all values to 0.0
+table.at[0, :] = 2.0  # Set all values in the first row to 2.0
+table.at[:, 1] = 2.0  # Set all values in the second column to 2.0
+table.at[2, 0] = 3.0  # Set the first column in the second-to-last row to 3.0
+
+table.close()
+```
+
+Which should give you the following:
+
+```
+╭──────────┬──────────┬──────────┬──────────╮
+│    0     │    1     │    2     │    3     │
+├──────────┼──────────┼──────────┼──────────┤
+│  2.0000  │  2.0000  │  2.0000  │  2.0000  │
+│  0.0000  │  2.0000  │  0.0000  │  0.0000  │
+│  3.0000  │  2.0000  │  0.0000  │  0.0000  │
+│  0.0000  │  2.0000  │  0.0000  │  0.0000  │
+╰──────────┴──────────┴──────────┴──────────╯
+```
+
+## Progress Bars
+
+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.
+
+> When using `interactive=1` mode, progress bars are be displayed only in the bottom row.
+
+### Embedded progress bars
+
+Embedded progress bars are displayed as an overlay under a table row that contains data.
+This allows you to see the progress and the new data all at once.
+Those progress bars are displayed 'under' the row and are aligned with the data columns.
+It is possible to customize the looks of the embedded progress bar by specyfing an argument when creating a table:
+
+```python
+from progress_table import ProgressTable
+
+table = ProgressTable(pbar_style_embed="dash")
+```
+
+Below we show a sample of available styles for embedded progress bars:
+
+`dash`
+
+```
+|   Name   |   Value   |   Number   |
+|-----------------------------------|
+|   test1  |    1.0    |     42     |
+|---test2--|----2.0->  |     37     |
+```
+
+`rich`
+
+```
+|   Name   |   Value   |   Number   |
+|-----------------------------------|
+|   test1  |    1.0    |     42     |
+|━━━test2━━|━━━━2.0━━  |     37     |
+```
+
+`under`
+
+```
+|   Name   |   Value   |   Number   |
+|-----------------------------------|
+|   test1  |    1.0    |     42     |
+|___test2__|____2.0__  |     37     |
+```
+
+---
+
+To see the exahustive list of available options, one can use the following code:
+
+```python
+from progress_table import styles
+
+print(styles.available_pbar_styles())
+```
+
+### Non-embedded progress bars
+
+Non-embedded progress bars are displayed as a separate row under the row that contains data.
+Optionally, you can force every progress bar, including the embedded ones, to look like a non-embedded and cover the data.
+You might want to do that if you aim for specific looks of your progress bars.
+
+```python
+from progress_table import ProgressTable
+
+table = ProgressTable(
+    pbar_style="square",  # specify specific style
+    pbar_embedded=False,  # force all progress bars to be non-embedded
+)
+```
+
+Below we show a sample of available styles for non-embedded progress bars
+
+---
+
+`square`
+
+```
+|   Name   |   Value   |   Number   |
+|-----------------------------------|
+|   test1  |    1.0    |     42     |
+|   test2  |    2.0    |     37     |
+|■■■■■■■■■■■■■■■■■■■■□□□□□□□□□□□□□□□|
+```
+
+`circle`
+
+```
+|   Name   |   Value   |   Number   |
+|-----------------------------------|
+|   test1  |    1.0    |     42     |
+|   test2  |    2.0    |     37     |
+| ●●●●●●●●●●●●●●●●●●◉○○○○○○○○○○○○○○○|
+```
+
+---
+
+As previously, you can see the exhaustive list of available options by using the following code:
+
+```python
+from progress_table import styles
+
+print(styles.available_pbar_styles())
+```
+
+> You can create custom styles by following code in `styles.py` file.
+
+### Infobar
+
+You can display detailed information like:
+
+* throughput
+* progress in percents
+* progress as the current step and total steps
+* ETA (estimated time arrival) - estimated time in seconds, minutes or hours when the progress bar will finish
+* custom description
+
+To add or remove some of this information, specify the arguments like below.
+Additionaly, you can create a progress bar object and specify
+all the options only for this specific progress bar.
+
+```python
+from progress_table import ProgressTable
+
+table = ProgressTable(
+    pbar_show_throughput=True,
+    pbar_show_progress=False,
+    pbar_show_percents=False,
+    pbar_show_eta=False,
+)
+
+pbar = table.pbar(
+    range(1000),
+    description="train epoch",
+    show_throughput=True,
+    show_progress=False,
+    show_percents=False,
+    show_eta=True,
+    style="circle",
+    style_embed="cdots",
+)
+```
+
+Which, when used, might look like this:
+
+```
+│           │           │           │           │
+│[train epoch, 24.1 it/s, ETA 53s] ●●●●●●●◉○○○○○│
+```
+
+### More progress bar customization
+
+There is more ways to customize the look and feel of your progress bars
+by adding special keywords to the style string:
+
+```python
+from progress_table import ProgressTable
+
+table = ProgressTable(pbar_style="angled alt red blue")
+```
+
+The example above would result in an angled-type pbar with alternative way of displaying empty bars,
+with filled bars colored red and empty bars colored blue. There's a separate style string
+for the embedded type progress bars - styling of embedded and non-embedded progress bars is indepedent.
+
+```python
+from progress_table import ProgressTable
+
+table = ProgressTable(pbar_style_embed="cdots red blue")
+```
+
+The available keywords are:
+
+* `alt` - alternative way of displaying empty bars, for example `■` instead of `□`.
+  This is only useful when using colors, otherwise you might not be able to differentiate between filled and empty bars.
+* `clean` - removes empty bars from the progress bar. Spaces are used instead.
+* `red`, `green`, `blue`, `yellow` and other colors available in colorama. If more than one is provided,
+  the first one is used for filled bars and the last one is used for empty bars.
+
+---
+
+Additionaly, you can specify the color of the progress bar using
+`color` and `color_empty` arguments when creating a progress bar object.
+This will override whatever color is set in `style` or `style_embed`.
+We can combine this option with `colorama.Back` to modify colors
+of the background instead of the foreground symbols.
+
+```python
+from progress_table import ProgressTable
+import colorama
+import time
+
+table = ProgressTable("a", "b", "c")
+table.add_rows(1)
+
+pbar = table.pbar(
+    range(100),
+    style_embed="hidden",
+    color=colorama.Back.RED,
+    color_empty=colorama.Back.BLUE,
+)
+
+for _ in pbar:
+    time.sleep(0.1)
+```
+
+Try the example above. It contains a different type of embedded progress bar.
+Here the typical progress bar symbols will are hidden,
+but the background color will show us the progress of the process.

progress_table-3.1.1/docs/integrations.md

@@ -0,0 +1,114 @@
+# Integrations
+
+Progress Table is not tied up to any specific deep learning framework.
+Because of it, it's lightweight and minimal. You can still easily integrate it with your code and your favourite framework. Below you will find examples of how to do this.
+
+# PyTorch
+
+This is an example of a simple custom training loop in PyTorch. We present two versions: without and with Progress Bar.
+
+### Without Progress Table
+
+Manual logging is often done in haste. It can look like this:
+
+```python
+...
+
+for epoch in range(n_epochs):
+    print(f'Epoch {epoch}')
+    cumulated_loss = 0
+    cumulated_accuracy = 0
+
+    for batch_idx, (x, y) in enumerate(train_loader):
+        loss, predictions = training_step(x, y)
+        accuracy = torch.mean((predictions == y).float()).item()
+
+        cumulated_loss += loss.item()
+        cumulated_accuracy += accuracy
+
+        if (batch_idx) % 100 == 0:
+            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}, Accuracy: {:.4f}'.format(
+                epoch,
+                n_epochs,
+                batch_idx,
+                len(train_loader),
+                cumulated_loss / (batch_idx + 1),
+                cumulated_accuracy / (batch_idx + 1),
+            ))
+
+print('Epoch [{}/{}], Step [FINISHED], Loss: {:.4f}, Accuracy: {:.4f}'.format(
+    epoch,
+    n_epochs,
+    cumulated_loss / len(train_loader),
+    cumulated_accuracy / len(train_loader),
+))
+```
+
+### With Progress Table
+
+When using Progress Table, you get detailed and clean logs. Moreover, your code is shorter, simpler and you get more functionality out of it.
+
+```python
+...
+
+table = ProgressTable("Epoch", "Step")
+table.add_columns(["Loss", "Accuracy"], aggregate="mean")
+
+for epoch in range(n_epochs):
+    table["Epoch"] = f"{epoch}/{n_epochs}"
+
+    for x, y in table(train_loader):
+        loss, predictions = training_step(x, y)
+        accuracy = torch.mean((predictions == y).float()).item()
+
+        table["Loss"] = loss
+        table["Accuracy"] = accuracy
+    table.next_row()
+
+table.close()
+```
+
+# Keras
+
+In case of PyTorch or TensorFlow, we often use custom training loops 
+where we can integrate Progress Table as shown above.
+What about Keras, where the progress bar is built-in the `model.fit` method?
+You can create a callback that will replace the progress bar built-in Keras
+with a progress table. Callback should inherit from `ProgbarLogger`.
+
+Here's an example:
+
+```python
+...
+
+table = ProgressTable()
+table.add_columns(["loss", "accuracy", "val_loss", "val_accuracy"], aggregate="mean")
+
+
+class TableCallback(tf.keras.callbacks.ProgbarLogger):
+    def __init__(self, table):
+        super().__init__()
+        self.table = table
+
+    def on_epoch_begin(self, epoch, logs=None):
+        pass
+
+    def on_epoch_end(self, epoch, logs=None):
+        self.table.update_from_dict(logs)
+        self.table.next_row()
+
+    def on_train_end(self, logs=None):
+        self.table.close()
+
+    def on_train_batch_end(self, batch, logs=None):
+        self.table.update_from_dict(logs)
+
+
+model.fit(
+    x_train,
+    y_train,
+    validation_data=(x_train, y_train),
+    callbacks=[TableCallback(table)],
+    epochs=10,
+)
+```

progress_table-3.1.1/docs/v3-notice.md

@@ -0,0 +1,52 @@
+# Version 3.0.0
+
+Version 3.0.0 of Progress Table is now available.
+
+It introduces:
+
+* Important internal changes to increase the stability.
+* Increased compatibility with some types of terminals.
+* Minor breaking changes in the API.
+
+## BREAKING API CHANGES
+
+---
+
+```
+ProgressTable(["c1", "c2", "c3"])
+```
+
+↑ becomes now ↓
+
+```
+ProgressTable("c1", "c2", "c3")
+# or
+ProgressTable(columns=["c1", "c2", "c3"])
+```
+
+---
+
+```
+ProgressTable([], 1, 20)
+```
+
+↑ will raise an error. Use named arguments instead ↓
+
+```
+ProgressTable(interactive=1, refresh_rate=20)
+```
+
+---
+
+```
+from progress_table import ProgressTableV1, ProgressTableV2
+```
+
+↑ multiple versions of ProgressTable are not available anymore. Use ↓
+
+```
+from progress_table import ProgressTable
+```
+
+---
+

progress_table-3.1.1/examples/brown2d.py

@@ -0,0 +1,115 @@
+#  Copyright (c) 2022-2025 Szymon Mikler
+#  Licensed under the MIT License
+
+import math
+import random
+import time
+
+from progress_table import ProgressTable
+
+
+def calc_distance(pos):
+    return (pos[0] ** 2 + pos[1] ** 2) ** 0.5
+
+
+def get_color_by_distance(distance):
+    if distance < 20:
+        return "white"
+    elif distance < 40:
+        return "cyan"
+    elif distance < 60:
+        return "blue"
+    elif distance < 80:
+        return "magenta"
+    elif distance < 100:
+        return "red"
+    else:
+        return "yellow bold"
+
+
+def shift_rows_up(table, last_row_color):
+    num_rows = table.num_rows()
+    num_columns = table.num_columns()
+
+    for row in range(num_rows - 1):
+        for col in range(num_columns):
+            table.at[row, col] = table.at[row + 1, col]
+            table.at[row, col, "color"] = table.at[row + 1, col, "color"]
+    for col in range(num_columns):
+        table.at[-2, col, "color"] = last_row_color
+
+
+def main(random_seed=None, sleep_duration=0.001, **overrides):
+    if random_seed is None:
+        random_seed = random.randint(0, 100)
+    random.seed(random_seed)
+
+    table = ProgressTable(
+        pbar_embedded=False,
+        pbar_style="full clean blue",
+        **overrides,
+    )
+
+    TARGET_DISTANCE = 100
+
+    PARTICLE_VELOCITY = 1
+    PARTICLE_MOMENTUM = 0.999
+
+    MAX_ROWS = 20
+    STEP_SIZE = 100
+
+    distance_pbar = table.pbar(
+        TARGET_DISTANCE,
+        description="Distance",
+        show_throughput=False,
+        show_progress=True,
+    )
+
+    current_position = (0, 0)
+    current_velocity = PARTICLE_VELOCITY
+
+    print("Particle will move randomly in 2D space.")
+    print(f"Simulation stops when it reaches distance of {TARGET_DISTANCE} from the center.")
+
+    tick = 0
+    pbar_momentum = 0
+    while calc_distance(current_position) < TARGET_DISTANCE:
+        random_direction = random.uniform(0, 2 * 3.1415)
+        new_velocity = random.uniform(0, PARTICLE_VELOCITY * 2)
+        current_velocity = current_velocity * PARTICLE_MOMENTUM + new_velocity * (1 - PARTICLE_MOMENTUM)
+        move_vector = (
+            current_velocity * math.cos(random_direction),
+            current_velocity * math.sin(random_direction),
+        )
+        current_position = (
+            current_position[0] + move_vector[0],
+            current_position[1] + move_vector[1],
+        )
+        distance_from_center = calc_distance(current_position)
+
+        tick += 1
+        table["tick"] = tick
+        table["velocity"] = current_velocity
+        table["position X"] = current_position[0]
+        table["position Y"] = current_position[1]
+        table["distance from center"] = distance_from_center
+
+        pbar_momentum = pbar_momentum * 0.95 + int(distance_from_center) * 0.05
+        distance_pbar.set_step(round(pbar_momentum))
+
+        if tick % STEP_SIZE == 0:
+            color = get_color_by_distance(distance_from_center)
+            if table.num_rows() > MAX_ROWS:
+                shift_rows_up(table, last_row_color=color)
+            else:
+                table.next_row(color=color)
+
+        time.sleep(sleep_duration)
+
+    color = get_color_by_distance(100)
+    table.next_row(color=color)
+    table.close()
+
+
+if __name__ == "__main__":
+    main()

progress_table-3.1.1/examples/download_v1.py

@@ -0,0 +1,92 @@
+#  Copyright (c) 2022-2025 Szymon Mikler
+#  Licensed under the MIT License
+import random
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+import colorama
+
+from progress_table import ProgressTable
+
+
+def create_random_file_info():
+    info = {}
+    index = random.randint(0, 1000)
+    types = ["image_.jpg", "video_.mp4", "archive_.zip", "movie_.avi"]
+    info["name"] = random.choice(types).replace("_", str(index))
+    info["size int"] = random.randint(1, 1000)
+    info["size unit"] = random.choice(["KB", "MB", "GB"])
+    info["time"] = 2 + random.random() * 10
+    return info
+
+
+NUM_FILES = 15
+files_to_download = [create_random_file_info() for _ in range(NUM_FILES)]
+
+
+table = ProgressTable(
+    pbar_show_progress=False,
+    pbar_show_throughput=False,
+    pbar_show_eta=True,
+    default_column_width=8,
+    default_header_color="bold",
+)
+
+main_pbar = table.pbar(
+    NUM_FILES,
+    position=1,
+    show_progress=True,
+    style="square clean blue",
+)
+
+
+def fake_download(idx, file_info):
+    # Modify pbar styling so that emebedded pbar shows color only
+    pbar = table.pbar(1, position=idx, static=True, style_embed="hidden", color=colorama.Back.BLACK)
+
+    # Update table values in a specifc row
+    table.update("total size", str(file_info["size int"]) + " " + file_info["size unit"], row=idx)
+    table.update("name", file_info["name"], row=idx)
+    table.update("seeds", random.randint(1, 30), row=idx)
+    table.update("peers", random.randint(0, 5), row=idx)
+
+    number_of_errors = 0
+
+    t0 = time.time()
+    td = 0
+    while True:
+        pbar.set_step(td / file_info["time"])  # Set specific pbar progress
+
+        # Maybe add an error to the error counter
+        if random.random() < 0.004:
+            number_of_errors += 1
+            random_delay = random.random()
+            time.sleep(random_delay)
+            t0 += random_delay
+
+        downloaded_units = int(td / file_info["time"] * file_info["size int"])
+        table.update("downloaded", str(downloaded_units) + " " + file_info["size unit"], row=idx)
+        table.update("warnings", number_of_errors, row=idx)
+        time.sleep(0.01)
+
+        td = time.time() - t0
+        if td > file_info["time"]:
+            break
+    pbar.close()
+    main_pbar.update()
+
+
+table.add_column("name", alignment="right", width=25)
+table.add_columns("total size", "downloaded", "seeds", "peers", "warnings")
+table.add_rows(len(files_to_download), color="blue")
+
+threads = []
+executor = ThreadPoolExecutor()
+
+for idx, pkg in enumerate(files_to_download):
+    threads.append(executor.submit(fake_download, idx, pkg))
+
+for thread in threads:
+    thread.result()
+
+table.close()

progress_table-3.1.1/examples/download_v2.py

@@ -0,0 +1,96 @@
+#  Copyright (c) 2022-2025 Szymon Mikler
+#  Licensed under the MIT License
+import random
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+import colorama
+
+from progress_table import ProgressTable
+
+
+def create_random_file_info():
+    info = {}
+    index = random.randint(0, 1000)
+    types = ["image_.jpg", "video_.mp4", "archive_.zip", "movie_.avi"]
+    info["name"] = random.choice(types).replace("_", str(index))
+    info["size int"] = random.randint(1, 1000)
+    info["size unit"] = random.choice(["KB", "MB", "GB"])
+    info["time"] = 2 + random.random() * 10
+    return info
+
+
+NUM_FILES = 40
+files_to_download = [create_random_file_info() for _ in range(NUM_FILES)]
+
+
+table = ProgressTable(
+    pbar_show_progress=False,
+    pbar_show_throughput=False,
+    pbar_show_eta=True,
+    default_column_width=8,
+    default_header_color="bold",
+)
+
+main_pbar = table.pbar(
+    NUM_FILES,
+    position=1,
+    show_progress=True,
+    style="square clean blue",
+)
+
+
+def fake_download(file_info):
+    # Modify pbar styling so that emebedded pbar shows color only
+    idx = table.num_rows() - 1
+    table.next_row()
+
+    pbar = table.pbar(1, position=idx, static=True, style_embed="hidden", color=colorama.Back.BLACK)
+
+    # Update table values in a specifc row
+    table.update("total size", str(file_info["size int"]) + " " + file_info["size unit"], row=idx)
+    table.update("name", file_info["name"], row=idx)
+    table.update("seeds", random.randint(1, 30), row=idx)
+    table.update("peers", random.randint(0, 5), row=idx)
+
+    number_of_errors = 0
+
+    t0 = time.time()
+    td = 0
+    while True:
+        pbar.set_step(td / file_info["time"])  # Set specific pbar progress
+
+        # Maybe add an error to the error counter
+        if random.random() < 0.004:
+            number_of_errors += 1
+            random_delay = random.random()
+            time.sleep(random_delay)
+            t0 += random_delay
+
+        downloaded_units = int(td / file_info["time"] * file_info["size int"])
+        table.update("downloaded", str(downloaded_units) + " " + file_info["size unit"], row=idx)
+        table.update("warnings", number_of_errors, row=idx)
+        time.sleep(0.01)
+
+        td = time.time() - t0
+        if td > file_info["time"]:
+            break
+    pbar.close()
+    main_pbar.update()
+
+
+table.add_column("name", alignment="right", width=25)
+table.add_columns("total size", "downloaded", "seeds", "peers", "warnings")
+
+threads = []
+executor = ThreadPoolExecutor()
+
+for _idx, pkg in enumerate(files_to_download):
+    threads.append(executor.submit(fake_download, pkg))
+    random_wait_time = random.randint(1, 10)
+    time.sleep(random_wait_time / 10)
+
+for thread in threads:
+    thread.result()
+
+table.close()

progress_table-3.1.1/examples/tictactoe.py

@@ -0,0 +1,85 @@
+#  Copyright (c) 2022-2025 Szymon Mikler
+#  Licensed under the MIT License
+
+import random
+import time
+
+from progress_table import ProgressTable
+
+BOARD_SIZE = 10
+STREAK_LENGTH = 5
+
+
+def main(random_seed=None, sleep_duration=0.05, **overrides):
+    if random_seed is None:
+        random_seed = random.randint(0, 100)
+    random.seed(random_seed)
+
+    table = ProgressTable(
+        pbar_embedded=False,
+        default_column_width=1,
+        print_header_on_top=False,
+        pbar_style="circle alt red",
+        **overrides,
+    )
+
+    print("Two players are playing tic-tac-toe.")
+    print(f"The first to get a streak of {STREAK_LENGTH} wins.")
+
+    # Use convenience method to add multiple columns at once
+    table.add_columns(BOARD_SIZE)
+
+    # Adding multiple new rows at once is also possible
+    # We get the 1-st row automatically, so we add one less
+    table.add_rows(BOARD_SIZE, split=True)
+
+    sign = 0
+    x = 0
+    y = 0
+
+    win_row_slice = None
+    win_col_slice = None
+    for _i in table(BOARD_SIZE * BOARD_SIZE, show_throughput=False, show_progress=True):
+        current_symbol = True
+        while current_symbol:
+            x = random.randint(0, BOARD_SIZE - 1)
+            y = random.randint(0, BOARD_SIZE - 1)
+            current_symbol = table.at[y, x]
+        sign = 1 - sign
+
+        table.at[y, x] = "X" if sign else "O"
+        table.at[y, x, "COLOR"] = "CYAN" if sign else "BLUE"
+
+        finished = False
+        for row_idx in range(BOARD_SIZE):
+            row = table.at[row_idx, :]
+            for j in range(BOARD_SIZE - STREAK_LENGTH):
+                values = set(row[j : j + STREAK_LENGTH])
+                if values == {"X"} or values == {"O"}:
+                    win_row_slice = slice(row_idx, row_idx + 1)
+                    win_col_slice = slice(j, j + STREAK_LENGTH)
+                    finished = True
+        for col_idx in range(BOARD_SIZE):
+            col = table.at[:, col_idx]
+
+            for j in range(BOARD_SIZE - STREAK_LENGTH):
+                values = set(col[j : j + STREAK_LENGTH])
+                if values == {"X"} or values == {"O"}:
+                    win_row_slice = slice(j, j + STREAK_LENGTH)
+                    win_col_slice = slice(col_idx, col_idx + 1)
+                    finished = True
+
+        if finished:
+            break
+        time.sleep(sleep_duration)
+
+    # Flashing the winner
+    for color in ["bold white", "bold red"] * 8:
+        table.at[win_row_slice, win_col_slice, "COLOR"] = color
+        time.sleep(0.1)
+
+    table.close()
+
+
+if __name__ == "__main__":
+    main()

progress_table-3.1.1/examples/training.py

@@ -0,0 +1,138 @@
+#  Copyright (c) 2022-2025 Szymon Mikler
+#  Licensed under the MIT License
+
+import random
+import time
+
+try:
+    import numpy as np
+except ImportError as ex:
+    raise ImportError("Numpy is required to run the example!") from ex
+
+try:
+    from sklearn.datasets import load_iris
+    from sklearn.model_selection import train_test_split
+    from sklearn.utils import shuffle
+except ImportError as ex:
+    raise ImportError("Scikit-learn is required to run the example!") from ex
+
+from progress_table import ProgressTable
+
+# Training parameters
+SGD_LR = 0.01
+NUM_EPOCHS = 15
+SLEEP_DURATION = 0.04
+
+
+def softmax(x):
+    exp = np.exp(x)
+    return exp / np.sum(exp, axis=1, keepdims=True)
+
+
+def log_softmax(x):
+    bot = np.sum(np.exp(x), axis=1, keepdims=True)
+    return x - np.log(bot)
+
+
+def cross_entropy_loss(targets, logits):
+    # Simulate heavy computation
+    time.sleep(SLEEP_DURATION)
+
+    assert len(targets) == len(logits)
+    num_elements = len(targets)
+
+    logits = log_softmax(logits)
+    return -logits[np.arange(num_elements), targets]
+
+
+def cross_entropy_loss_grads(targets, logits):
+    one_hot_targets = np.zeros_like(logits)
+    one_hot_targets[np.arange(len(targets)), targets] = 1
+    return one_hot_targets - softmax(logits)
+
+
+def model_grads(targets, logits, inputs):
+    cross_entropy_grads = cross_entropy_loss_grads(targets, logits)
+    return inputs.T @ cross_entropy_grads
+
+
+def main(random_seed=None, sleep_duration=SLEEP_DURATION, **overrides):
+    if random_seed is None:
+        random_seed = random.randint(0, 100)
+    global SLEEP_DURATION
+    SLEEP_DURATION = sleep_duration
+
+    random.seed(random_seed)
+    np.random.seed(random_seed)
+
+    table = ProgressTable(
+        pbar_embedded=False,  # Do not use embedded pbar
+        pbar_style="angled alt red blue",
+        **overrides,
+    )
+    print("Training a simple linear model on the Iris dataset.")
+
+    # Loading dataset
+    X, Y = load_iris(return_X_y=True)
+    X_train, X_valid, Y_train, Y_valid = train_test_split(X, Y)
+    weights = np.random.rand(4, 3)
+
+    for epoch in table(NUM_EPOCHS, show_throughput=False, show_eta=True):
+        table["epoch"] = epoch
+        # Shuffling training dataset each epoch
+        X_train, Y_train = shuffle(X_train, Y_train)  # type: ignore
+
+        NUM_BATCHES = 16
+        X_batches = np.array_split(X_train, NUM_BATCHES)
+        Y_batches = np.array_split(Y_train, NUM_BATCHES)
+
+        for batch in table(zip(X_batches, Y_batches), total=NUM_BATCHES, description="train epoch"):
+            x, y = batch
+            logits = x @ weights
+
+            # Computing and applying gradient update
+            weights_updates = model_grads(y, logits, x)
+            weights = weights + SGD_LR * weights_updates
+
+            # Computing loss function for the logging
+            accuracy = np.mean(np.argmax(logits, axis=1) == y)
+            loss_value = np.mean(cross_entropy_loss(y, logits))
+
+            # We're using .update instead of __setitem__ so that we can specify column details
+            table.update("train loss", loss_value, aggregate="mean", color="blue")
+            table.update("train accuracy", accuracy, aggregate="mean", color="blue bold")
+
+        run_validation = epoch % 5 == 4 or epoch == NUM_EPOCHS - 1
+        if run_validation:
+            NUM_BATCHES = 32
+            X_batches = np.array_split(X_valid, NUM_BATCHES)
+            Y_batches = np.array_split(Y_valid, NUM_BATCHES)
+
+            for batch in table(zip(X_batches, Y_batches), total=NUM_BATCHES, description="valid epoch"):
+                x, y = batch
+                logits = x @ weights
+                accuracy = np.mean(np.argmax(logits, axis=1) == y)
+                loss_value = np.mean(cross_entropy_loss(y, logits))
+
+                # Use aggregation weight equal to batch size to get real mean over the validation dataset
+                batch_size = x.shape[0]
+                table.update(
+                    "valid loss",
+                    loss_value,
+                    weight=batch_size,
+                    aggregate="mean",
+                    color="red",
+                )
+                table.update(
+                    "valid accuracy",
+                    accuracy,
+                    weight=batch_size,
+                    aggregate="mean",
+                    color="red bold",
+                )
+        table.next_row(split=run_validation)
+    table.close()
+
+
+if __name__ == "__main__":
+    main()

{progress_table-3.0.2 → progress_table-3.1.1}/progress_table/__init__.py

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

{progress_table-3.0.2 → progress_table-3.1.1}/progress_table/progress_table.py

@@ -15,12 +15,17 @@ import time
 from collections.abc import Callable, Iterable, Iterator, Sized
 from dataclasses import dataclass
 from threading import Thread
-from typing import TextIO
+from typing import Any, TextIO
 
 from colorama import Style
 
 from progress_table import styles
-from progress_table.common import CURSOR_UP, ColorFormat, ColorFormatTuple, maybe_convert_to_colorama
+from progress_table.common import (
+    CURSOR_UP,
+    ColorFormat,
+    ColorFormatTuple,
+    maybe_convert_to_colorama,
+)
 
 ######################
 ## HELPER FUNCTIONS ##
@@ -83,8 +88,8 @@ def get_aggregate_fn(aggregate: None | str | Callable) -> Callable:
     raise ValueError(msg)
 
 
-def get_default_format_fn(decimal_places: int) -> Callable[[object], str]:
-    def fmt(x: object) -> str:
+def get_default_format_fn(decimal_places: int) -> Callable[[Any], str]:
+    def fmt(x: Any) -> str:
         if isinstance(x, int):
             return str(x)
         try:
@@ -104,13 +109,14 @@ def get_default_format_fn(decimal_places: int) -> Callable[[object], str]:
 class DataRow:
     """Basic unit of data storage for the table."""
 
-    values: dict[str, object]
+    values: dict[str, Any]
     weights: dict[str, float]
     colors: dict[str, str]
+    user: bool = False
 
     def is_empty(self) -> bool:
         """Check if the row is empty."""
-        return not any(self.values)
+        return not any(self.values) and not self.user
 
 
 class ProgressTable:
@@ -144,7 +150,7 @@ class ProgressTable:
         pbar_style_embed: str | styles.PbarStyleBase = "cdots",
         print_header_on_top: bool = True,
         print_header_every_n_rows: int = 30,
-        custom_cell_format: Callable[[object], str] | None = None,
+        custom_cell_format: Callable[[Any], str] | None = None,
         table_style: str | styles.TableStyleBase = "round",
         file: TextIO | list[TextIO] | tuple[TextIO] | None = None,
         # DEPRECATED ARGUMENTS
@@ -387,7 +393,7 @@ class ProgressTable:
     def update(
         self,
         name: str,
-        value: object,
+        value: Any,
         *,
         row: int = -1,
         weight: float = 1.0,
@@ -429,8 +435,12 @@ class ProgressTable:
         if self.interactive > 0:
             self._append_or_update_display_row(data_row_index)
 
-    def __setitem__(self, key: str | tuple[str, int], value: object) -> None:
+    def __setitem__(self, key: str | tuple[str, int], value: Any) -> None:
         """Update value in the current row. Calls 'update'."""
+        if isinstance(key, slice):
+            msg = "slicing not supported! Did you want to use 'table.at[:]' indexer?"
+            raise IndexError(msg)
+
         if isinstance(key, tuple):
             name, row = key
             if isinstance(name, int) and isinstance(row, str):
@@ -441,8 +451,12 @@ class ProgressTable:
         assert isinstance(row, int), f"Row {row} has to be an integer, not {type(row)}!"
         self.update(name, value, row=row, weight=1)
 
-    def __getitem__(self, key: str | tuple[str, int]) -> object | None:
+    def __getitem__(self, key: str | tuple[str, int]) -> Any:
         """Get the value from the current row in table."""
+        if isinstance(key, slice):
+            msg = "slicing not supported! Did you want to use 'table.at[:]' indexer?"
+            raise IndexError(msg)
+
         if isinstance(key, tuple):
             name, row = key
             if isinstance(name, int) and isinstance(row, int):
@@ -454,7 +468,7 @@ class ProgressTable:
         assert isinstance(row, int), f"Row {row} has to be an integer, not {type(row)}!"
         return self._data_rows[row].values.get(name, None)
 
-    def update_from_dict(self, dictionary: dict[str, object]) -> None:
+    def update_from_dict(self, dictionary: dict[str, Any]) -> None:
         """Update multiple values in the current row."""
         for key, value in dictionary.items():
             self.update(key, value)
@@ -500,7 +514,7 @@ class ProgressTable:
         row.colors = {**self._resolve_row_color_dict(color), **row.colors}
 
         # Refreshing the existing row is necessary to apply colors
-        # Or - if row is empty, this will cause the first addition to display rows
+        # Or - if row is new - this will add it to display rows
         self._append_or_update_display_row(data_row_index)
 
         self._append_new_empty_data_row()
@@ -513,9 +527,18 @@ class ProgressTable:
 
     def add_row(self, *values, **kwds) -> None:
         """Mimicking rich.table behavior for adding full rows in one call."""
+        if not self._data_rows[-1].is_empty():
+            self.next_row(**kwds)
+
         for key, value in zip(self.column_names, values):
             self.update(key, value)
-        self.next_row(**kwds)
+
+        # The row was explicitly added, make sure it is displayed
+        data_row_index = len(self._data_rows) - 1
+        self._append_or_update_display_row(data_row_index)
+
+        # Mark row as explicitly added by the user
+        self._data_rows[data_row_index].user = True
 
     def add_rows(self, *rows, **kwds) -> None:
         """Like `add_row` but adds multiple rows at once.
@@ -574,14 +597,14 @@ class ProgressTable:
 
             self._append_or_update_display_row("USER WRITE " + line)
 
-    def to_list(self) -> list[list[object]]:
+    def to_list(self) -> list[list[Any]]:
         """Convert to Python nested list."""
         values = [[row.values.get(col, None) for col in self.column_names] for row in self._data_rows]
         if self._data_rows[-1].is_empty():
             values.pop(-1)
         return values
 
-    def to_numpy(self) -> object:
+    def to_numpy(self) -> Any:
         """Convert to numpy array.
 
         Numpy library is required.
@@ -590,7 +613,7 @@ class ProgressTable:
 
         return np.array(self.to_list())
 
-    def to_df(self) -> object:
+    def to_df(self) -> Any:
         """Convert to pandas DataFrame.
 
         Pandas library is required.
@@ -809,7 +832,7 @@ class ProgressTable:
         color_colorama = {column: maybe_convert_to_colorama(color) for column, color in color.items()}
         return {col: self.column_colors[col] + color_colorama[col] for col in color}
 
-    def _apply_cell_formatting(self, value: object, column_name: str, color: str) -> str:
+    def _apply_cell_formatting(self, value: Any, column_name: str, color: str) -> str:
         str_value = self.custom_cell_format(value)
         width = self.column_widths[column_name]
         alignment = self.column_alignments[column_name]
@@ -1284,7 +1307,7 @@ class TableAtIndexer:
         column_names = self.table.column_names[cols] if isinstance(cols, slice) else [self.table.column_names[cols]]
         return row_indices, column_names, mode
 
-    def __setitem__(self, key: slice | tuple, value: object) -> None:
+    def __setitem__(self, key: slice | tuple, value: Any) -> None:
         """Set the values, colors, or weights of a slice in the table."""
         row_indices, column_names, edit_mode = self._parse_index(key)
         if edit_mode == "colors":

{progress_table-3.0.2 → progress_table-3.1.1}/progress_table/styles.py

@@ -32,8 +32,6 @@ def _parse_colors_from_description(description: str) -> tuple[str, str, str]:
 class UnknownStyleError(ValueError):
     """Raised when style description is not recognized."""
 
-    pass
-
 
 def parse_pbar_style(description: str | PbarStyleBase) -> PbarStyleBase:
     """Parse progress bar style description and return a style object.

{progress_table-3.0.2 → progress_table-3.1.1}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
 ]
-readme = "README.md"
+readme = "README_pypi.md"
 
 [project.urls]
 Home = "https://github.com/gahaalt/progress-table"
@@ -36,7 +36,7 @@ dev = ["black", "isort", "build", "twine"]
 path = "progress_table/__init__.py"
 
 [tool.hatch.build.targets.sdist]
-include = ["progress_table", "README.md"]
+include = ["progress_table", "examples", "docs", "README.md"]
 
 [tool.hatch.build.targets.wheel]
 packages = ["progress_table"]
@@ -44,8 +44,7 @@ packages = ["progress_table"]
 [tool.hatch.metadata.hooks.custom]
 path = "hooks.py"
 
-
-# %%
+# %% TOOLS
 
 [tool.pyright]
 typeCheckingMode = "standard"
@@ -53,8 +52,23 @@ exclude = ["devel", "build", "dist"]
 
 [tool.ruff]
 line-length = 120
-fix = true
 target-version = "py37"
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "B"]
+
+# %%
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+
+[tool.mypy]
+ignore_missing_imports = true
+exclude = ["devel", "build", "dist"]
+
+[tool.isort]
+profile = "black"
+line_length = 120
+
+[tool.black]
+line_length = 120