progress-table 0.1.27__tar.gz → 1.0.1__tar.gz

{progress-table-0.1.27 → progress-table-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: progress-table
-Version: 0.1.27
+Version: 1.0.1
 Summary: Display progress as a pretty table in the command line.
 Home-page: https://github.com/gahaalt/progress-table.git
 Author: Szymon Mikler
@@ -31,6 +31,10 @@ Designed to monitor machine learning experiments, but can be used for anything.
 Allows you to quickly see what is going on.
 Increases readability and cuteness of your command line logging.
 
+> Note: version 1.0 introduced new features and changes of default behaviour.
+>
+> The old version is still available as `progress_table.ProgressTableV0`.
+
 ## Features
 
 * Displaying pretty table in the terminal
@@ -60,22 +64,30 @@ import time
 
 from progress_table import ProgressTable
 
-# Define the columns at the beginning
-table = ProgressTable(
-    columns=["step", "x", "x squared"],
+# Create table object:
+table = ProgressTable()
 
-    # Default arguments:
+# Or customize its settings:
+table = ProgressTable(
+    columns=["step"],
     refresh_rate=10,
     num_decimal_places=4,
-    default_column_width=8,
-    default_column_alignment="center",
+    default_column_width=None,
+    default_column_color=None,
+    default_column_alignment=None,
+    default_column_aggregate=None,
+    default_row_color=None,
+    embedded_progress_bar=True,
+    pbar_show_throughput=True,
+    pbar_show_progress=False,
     print_row_on_update=True,
     reprint_header_every_n_rows=30,
     custom_format=None,
-    embedded_progress_bar=False,
-    table_style="normal",
+    table_style="round",
     file=sys.stdout,
 )
+
+# You can define the columns at the beginning
 table.add_column("x", width=3)
 table.add_column("x root", color="red")
 table.add_column("random average", color=["bright", "red"], aggregate="mean")
@@ -83,10 +95,9 @@ table.add_column("random average", color=["bright", "red"], aggregate="mean")
 for step in range(10):
     x = random.randint(0, 200)
 
-    # There are two equivalent ways to add new values
-    # First:
-    table["step"] = step
+    # There are two ways to add new values:
     table["x"] = x
+    table["step"] = step
     # Second:
     table.update("x root", x ** 0.5)
     table.update("x squared", x ** 2)
@@ -105,8 +116,8 @@ table.close()
 
 # Export your data
 data = table.to_list()
-pandas_df = table.to_df()
-np_array = table.to_numpy()
+pandas_df = table.to_df()  # Requires pandas to be installed
+np_array = table.to_numpy()  # Requires numpy to be installed
 ```
 
 ![example](https://github.com/gahaalt/progress-table/blob/main/images/example-output4.gif?raw=true)

{progress-table-0.1.27 → progress-table-1.0.1}/README.md

@@ -11,6 +11,10 @@ Designed to monitor machine learning experiments, but can be used for anything.
 Allows you to quickly see what is going on.
 Increases readability and cuteness of your command line logging.
 
+> Note: version 1.0 introduced new features and changes of default behaviour.
+>
+> The old version is still available as `progress_table.ProgressTableV0`.
+
 ## Features
 
 * Displaying pretty table in the terminal
@@ -40,22 +44,30 @@ import time
 
 from progress_table import ProgressTable
 
-# Define the columns at the beginning
-table = ProgressTable(
-    columns=["step", "x", "x squared"],
+# Create table object:
+table = ProgressTable()
 
-    # Default arguments:
+# Or customize its settings:
+table = ProgressTable(
+    columns=["step"],
     refresh_rate=10,
     num_decimal_places=4,
-    default_column_width=8,
-    default_column_alignment="center",
+    default_column_width=None,
+    default_column_color=None,
+    default_column_alignment=None,
+    default_column_aggregate=None,
+    default_row_color=None,
+    embedded_progress_bar=True,
+    pbar_show_throughput=True,
+    pbar_show_progress=False,
     print_row_on_update=True,
     reprint_header_every_n_rows=30,
     custom_format=None,
-    embedded_progress_bar=False,
-    table_style="normal",
+    table_style="round",
     file=sys.stdout,
 )
+
+# You can define the columns at the beginning
 table.add_column("x", width=3)
 table.add_column("x root", color="red")
 table.add_column("random average", color=["bright", "red"], aggregate="mean")
@@ -63,10 +75,9 @@ table.add_column("random average", color=["bright", "red"], aggregate="mean")
 for step in range(10):
     x = random.randint(0, 200)
 
-    # There are two equivalent ways to add new values
-    # First:
-    table["step"] = step
+    # There are two ways to add new values:
     table["x"] = x
+    table["step"] = step
     # Second:
     table.update("x root", x ** 0.5)
     table.update("x squared", x ** 2)
@@ -85,8 +96,8 @@ table.close()
 
 # Export your data
 data = table.to_list()
-pandas_df = table.to_df()
-np_array = table.to_numpy()
+pandas_df = table.to_df()  # Requires pandas to be installed
+np_array = table.to_numpy()  # Requires numpy to be installed
 ```
 
 ![example](https://github.com/gahaalt/progress-table/blob/main/images/example-output4.gif?raw=true)

progress-table-1.0.1/progress_table/__init__.py

@@ -0,0 +1,8 @@
+#  Copyright (c) 2022 Szymon Mikler
+
+from progress_table.v0.progress_table import ProgressTableV0
+from progress_table.v1.progress_table import ProgressTableV1
+
+ProgressTable = ProgressTableV1
+
+__all__ = ["ProgressTable", "ProgressTableV0", "ProgressTableV1"]

{progress-table-0.1.27 → progress-table-1.0.1}/progress_table/devel.py

@@ -3,14 +3,13 @@ import shutil
 import sys
 import time
 
-from progress_table import ProgressTable
+from progress_table import ProgressTableV1
 
 shutil.get_terminal_size()
 
 # Define the columns at the beginning
-table = ProgressTable(
+table = ProgressTableV1(
     columns=["step", "x", "x squared"],
-
     # Default arguments:
     refresh_rate=10,
     num_decimal_places=4,
@@ -35,17 +34,17 @@ for step in range(100):
     table["step"] = step
     table["x"] = x
     # Second:
-    table.update("x root", x ** 0.5)
-    table.update("x squared", x ** 2)
+    table.update("x root", x**0.5)
+    table.update("x squared", x**2)
 
     # Display the progress bar by wrapping the iterator
     for _ in table(10):
         # You can use weights for aggregated values
         table.update("random average", random.random(), weight=1)
-        time.sleep(1)
+        time.sleep(0.1)
 
     # Go to the next row when you're ready
-    if step % 5 == 4:
+    if step % 5 == 0:
         split = True
     else:
         split = False

progress-table-1.0.1/progress_table/devel2.py

@@ -0,0 +1,60 @@
+import random
+import sys
+import time
+
+from progress_table import ProgressTableV1
+
+# Create table object:
+table = ProgressTableV1()
+
+# Or customize its settings:
+table = ProgressTableV1(
+    columns=["step"],
+    refresh_rate=10,
+    num_decimal_places=4,
+    default_column_width=None,
+    default_column_color=None,
+    default_column_alignment=None,
+    default_column_aggregate=None,
+    default_row_color=None,
+    embedded_progress_bar=True,
+    pbar_show_throughput=True,
+    pbar_show_progress=False,
+    print_row_on_update=True,
+    reprint_header_every_n_rows=30,
+    custom_format=None,
+    table_style="round",
+    file=sys.stdout,
+)
+
+# You can define the columns at the beginning
+table.add_column("x", width=3)
+table.add_column("x root", color="red")
+table.add_column("random average", color=["bright", "red"], aggregate="mean")
+
+for step in table(iter(range(100))):
+    x = random.randint(0, 200)
+
+    # There are two ways to add new values:
+    table["x"] = x
+    table["step"] = step
+    # Second:
+    table.update("x root", x**0.5)
+    table.update("x squared", x**2)
+
+    # Display the progress bar by wrapping the iterator
+    for _ in range(10):  # -> Equivalent to `table(range(10))`
+        # You can use weights for aggregated values
+        table.update("random average", random.random(), weight=1)
+        time.sleep(0.02)
+
+    # Go to the next row when you're ready
+    table.next_row()
+
+# Close the table when it's ready
+table.close()
+
+# Export your data
+data = table.to_list()
+pandas_df = table.to_df()  # Requires pandas to be installed
+np_array = table.to_numpy()  # Requires numpy to be installed

{progress-table-0.1.27 → progress-table-1.0.1}/progress_table.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: progress-table
-Version: 0.1.27
+Version: 1.0.1
 Summary: Display progress as a pretty table in the command line.
 Home-page: https://github.com/gahaalt/progress-table.git
 Author: Szymon Mikler
@@ -31,6 +31,10 @@ Designed to monitor machine learning experiments, but can be used for anything.
 Allows you to quickly see what is going on.
 Increases readability and cuteness of your command line logging.
 
+> Note: version 1.0 introduced new features and changes of default behaviour.
+>
+> The old version is still available as `progress_table.ProgressTableV0`.
+
 ## Features
 
 * Displaying pretty table in the terminal
@@ -60,22 +64,30 @@ import time
 
 from progress_table import ProgressTable
 
-# Define the columns at the beginning
-table = ProgressTable(
-    columns=["step", "x", "x squared"],
+# Create table object:
+table = ProgressTable()
 
-    # Default arguments:
+# Or customize its settings:
+table = ProgressTable(
+    columns=["step"],
     refresh_rate=10,
     num_decimal_places=4,
-    default_column_width=8,
-    default_column_alignment="center",
+    default_column_width=None,
+    default_column_color=None,
+    default_column_alignment=None,
+    default_column_aggregate=None,
+    default_row_color=None,
+    embedded_progress_bar=True,
+    pbar_show_throughput=True,
+    pbar_show_progress=False,
     print_row_on_update=True,
     reprint_header_every_n_rows=30,
     custom_format=None,
-    embedded_progress_bar=False,
-    table_style="normal",
+    table_style="round",
     file=sys.stdout,
 )
+
+# You can define the columns at the beginning
 table.add_column("x", width=3)
 table.add_column("x root", color="red")
 table.add_column("random average", color=["bright", "red"], aggregate="mean")
@@ -83,10 +95,9 @@ table.add_column("random average", color=["bright", "red"], aggregate="mean")
 for step in range(10):
     x = random.randint(0, 200)
 
-    # There are two equivalent ways to add new values
-    # First:
-    table["step"] = step
+    # There are two ways to add new values:
     table["x"] = x
+    table["step"] = step
     # Second:
     table.update("x root", x ** 0.5)
     table.update("x squared", x ** 2)
@@ -105,8 +116,8 @@ table.close()
 
 # Export your data
 data = table.to_list()
-pandas_df = table.to_df()
-np_array = table.to_numpy()
+pandas_df = table.to_df()  # Requires pandas to be installed
+np_array = table.to_numpy()  # Requires numpy to be installed
 ```
 
 ![example](https://github.com/gahaalt/progress-table/blob/main/images/example-output4.gif?raw=true)

{progress-table-0.1.27 → progress-table-1.0.1}/progress_table.egg-info/SOURCES.txt

@@ -5,8 +5,7 @@ setup.cfg
 setup.py
 progress_table/__init__.py
 progress_table/devel.py
-progress_table/progress_table.py
-progress_table/symbols.py
+progress_table/devel2.py
 progress_table/test_docs_automated.py
 progress_table.egg-info/PKG-INFO
 progress_table.egg-info/SOURCES.txt

{progress-table-0.1.27 → progress-table-1.0.1}/progress_table.egg-info/requires.txt

@@ -1,2 +1 @@
 colorama
-pandas

{progress-table-0.1.27 → progress-table-1.0.1}/pyproject.toml

@@ -3,11 +3,11 @@ pythonpath = ["."]
 
 [tool.mypy]
 ignore_missing_imports = true
-exclude = "devel"
+exclude = ["devel", "build", "dist"]
 
 [tool.isort]
 profile = "black"
-line_length = 120
+line_length = 140
 
 [tool.black]
-line_length = 120
+line_length = 140

{progress-table-0.1.27 → progress-table-1.0.1}/setup.cfg

@@ -1,6 +1,6 @@
 [flake8]
-ignore = E203,W503
-max-line-length = 120
+ignore = E203,W503,E266
+max-line-length = 140
 exclude = devel
 
 [egg_info]

{progress-table-0.1.27 → progress-table-1.0.1}/setup.py

@@ -9,7 +9,7 @@ long_description = (this_directory / "README.md").read_text(encoding="UTF-8")
 
 setup(
     name="progress-table",
-    version="0.1.27",
+    version="1.0.1",
     url="https://github.com/gahaalt/progress-table.git",
     author="Szymon Mikler",
     author_email="sjmikler@gmail.com",
@@ -27,7 +27,7 @@ setup(
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
     ],
-    install_requires=["colorama", "pandas"],
+    install_requires=["colorama"],
     long_description=long_description,
     long_description_content_type="text/markdown",
 )

progress-table-0.1.27/progress_table/__init__.py

@@ -1,5 +0,0 @@
-#  Copyright (c) 2022 Szymon Mikler
-
-from .progress_table import ProgressTable
-
-__all__ = ["ProgressTable"]

progress-table-0.1.27/progress_table/progress_table.py

@@ -1,590 +0,0 @@
-#  Copyright (c) 2022 Szymon Mikler
-
-from __future__ import annotations
-
-import inspect
-import logging
-import math
-import shutil
-import sys
-import time
-from builtins import KeyError, staticmethod
-from collections import defaultdict
-from typing import Any, Callable, Dict, List, Tuple
-
-from colorama import Fore, Style
-
-from . import symbols
-
-ALL_COLOR_NAMES = [x for x in dir(Fore) if not x.startswith("__")]
-ALL_STYLE_NAMES = [x for x in dir(Style) if not x.startswith("__")]
-ALL_COLORS_STYLES_NAMES = ALL_COLOR_NAMES + ALL_STYLE_NAMES
-
-ALL_COLORS = [getattr(Fore, x) for x in ALL_COLOR_NAMES]
-ALL_STYLES = [getattr(Style, x) for x in ALL_STYLE_NAMES]
-ALL_COLORS_STYLES = ALL_COLORS + ALL_STYLES
-
-ITERATOR_LENGTH_UNKNOWN_WARNED_ONCE = False
-ITERATOR_LENGTH_CACHE: Dict[int, int] = {}
-
-
-class ProgressTable:
-    def __init__(
-        self,
-        columns: Tuple | List = (),
-        refresh_rate: int = 10,
-        num_decimal_places: int = 4,
-        default_column_width: int = 8,
-        default_column_alignment: str = "center",
-        default_show_throughput: bool = True,
-        default_show_progress: bool = False,
-        print_row_on_update: bool = True,
-        reprint_header_every_n_rows: int = 30,
-        custom_format: Callable[[Any], Any] | None = None,
-        embedded_progress_bar: bool = False,
-        table_style: str = "normal",
-        file=sys.stdout,
-    ):
-        """Progress Table instance.
-
-        Columns have to be specified before displaying the first row or launching a progress bar!
-
-        Args:
-            columns: Columns that will be displayed in the header. Columns can be provided directly in
-                     `__init__` or through methods `add_column` and `add_columns`. Columns added through
-                     `__init__` will have default settings like alignment, color and width, while
-                     columns added through methods can have those customized.
-            refresh_rate: The maximal number of times per second the last row of the Table will be refreshed.
-                          This applies only when using Progress Bar or when `print_row_on_update = True`.
-            num_decimal_places: This is only applicable when using the default formatting. This won't be used
-                                if `custom_format` is set. If applicable, for every displayed value except
-                                integers there will be an attempt to round it.
-            default_column_width: Width of the column excluding cell padding. This can be overwritten by
-                                  columns by using an argument in `add_column` method.
-            default_column_alignment: Alignment in the column. Can be aligned either to `left`, `right` or
-                                      `center` (default). This can be overwritten by columns by using
-                                      an argument in `add_column` method.
-            print_row_on_update: True by default. If False, the current row will be displayed only when
-                                 it's ready. Row is considered ready after calling `.next_row` or `.close`
-                                 methods.
-            reprint_header_every_n_rows: 30 by default. When table has a lot of rows, it can be useful to
-                                         remind what the header is. If True, hedaer will be displayed
-                                         periodically after the selected number of rows. 0 to supress.
-            custom_format: A function that allows specyfing custom formatting for values in cells.
-                           This function should be universal and work for all datatypes as inputs.
-                           It takes one value as an input and returns one value as an output.
-            embedded_progress_bar: False by default. If True, changes the way the progress bar looks.
-                                   Embedded version is more subtle, but does not prevent the current row
-                                   from being displayed. If False, the progress bar covers the current
-                                   row, preventing the user from seeing values that are being updated
-                                   until the progress bar finishes.
-            table_style: Change the borders of the table. Cause KeyError to see all the available styles.
-            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.
-        """
-        self.refresh_rate = refresh_rate
-        self.default_width = default_column_width
-        self.default_alignment = default_column_alignment
-        self.default_show_throughput = default_show_throughput
-        self.default_show_progress = default_show_progress
-        self.print_row_on_update = print_row_on_update
-        self.reprint_header_every_n_rows = reprint_header_every_n_rows
-        self.custom_format = custom_format or self.get_default_format_func(num_decimal_places)
-        self.embedded_progress_bar = embedded_progress_bar
-
-        if not isinstance(file, list) and not isinstance(file, tuple):
-            file = (file,)
-        self.files = file
-
-        # Helpers
-        self._widths: Dict[str, int] = {}
-        self._colors: Dict[str, str] = {}
-        self._alignment: Dict[str, str] = {}
-        self._aggregate: Dict[str, str | None] = {}
-        self._new_row: Dict[str, Any] = defaultdict(str)
-        self._aggregate_n: Dict[str, int] = defaultdict(int)
-
-        self.num_rows = 0
-        self.columns: List[str] = []
-        self.finished_rows: List[Dict[Any, Any]] = []
-
-        self._needs_line_ending = False
-        self._last_time_row_printed = 0
-        self._last_header_printed_at_row_count = 0
-
-        self.header_printed = False
-        self.progress_bar_active = False
-        self._refresh_progress_bar: Callable = lambda: None
-        self._needs_splitter = False
-
-        self._last_row_content = None
-
-        allowed_styles = [getattr(symbols, class_name) for class_name in dir(symbols)]
-        allowed_styles = [x for x in allowed_styles if inspect.isclass(x) and issubclass(x, symbols.Symbols)]
-        style_name_to_style = {x.name: x for x in allowed_styles if hasattr(x, "name")}
-
-        if table_style in style_name_to_style:
-            self._symbols = style_name_to_style[table_style]
-        else:
-            allowed_style_names = list(style_name_to_style)
-            raise KeyError(f"Style '{table_style}' not in {allowed_style_names}!")
-
-        for column in columns:
-            self.add_column(column)
-
-    @staticmethod
-    def get_default_format_func(decimal_places):
-        def fmt(x):
-            if isinstance(x, int):
-                return x
-            else:
-                try:
-                    return format(x, f".{decimal_places}f")
-                except Exception:
-                    return x
-
-        return fmt
-
-    def add_column(self, name, *, width=None, alignment=None, color=None, aggregate=None):
-        """Add column to the table.
-
-        Args:
-            name: Name of the column. Will be displayed in the header.
-            width: Width of the column. If width is smaller than the name, width will be automatically
-                   increased to the smallest possible value. This means setting `width=0` will set the column
-                   to the smallest possible width allowed by `name`.
-            alignment: Alignment of the data in the column.
-            color: Color of the header and the data in the column.
-            aggregate: By default, there's no aggregation. But if this is for example 'mean', then
-                       after every update in the current row, the mean of the provided values will be
-                       displayed. Aggregation is reset at every new row.
-        """
-        assert not self.header_printed, "Columns cannot be modified after displaying the first row!"
-
-        if name in self.columns:
-            logging.info(f"Column '{name}' already exists!")
-        else:
-            self.columns.append(name)
-
-        self._colors.setdefault(name, "")
-        if color is not None:
-            if isinstance(color, str):
-                color = [color]
-            for str_color in color:
-                byte_color = self._maybe_convert_to_colorama(str_color)
-                self._check_color(byte_color, str_color)
-                self._colors[name] += byte_color
-
-        alignment = alignment if alignment is not None else self.default_alignment
-        self._alignment[name] = alignment
-
-        assert aggregate in [
-            None,
-            "mean",
-            "sum",
-            "max",
-            "min",
-        ], "Allowed aggregate types: [None, 'mean', 'sum', 'max', 'min']"
-        self._aggregate[name] = aggregate
-
-        width = width if width is not None else self.default_width
-        if width < len(name):
-            width = len(name)
-        self._widths[name] = width
-
-    def add_columns(self, iterable, **kwds):
-        """Add multiple columns to the table."""
-        for column in iterable:
-            self.add_column(column, **kwds)
-
-    def next_row(self, save=True, split=False, header=False):
-        """End the current row."""
-        self._print_row()
-        self._maybe_line_ending()
-        if self.progress_bar_active:
-            self._refresh_progress_bar()
-        sys.stdout.flush()
-
-        if save and len(self._new_row) > 0:
-            self.finished_rows.append(self._new_row)
-            self.num_rows += 1
-
-        self._new_row = defaultdict(str)
-        self._aggregate_n = defaultdict(int)
-
-        if split:
-            self._needs_splitter = True
-
-        if header:
-            self._print_header(top=False)
-
-    def close(self):
-        """End the table and close it."""
-        self._needs_splitter = False
-
-        self.next_row()
-        self._print_bottom_bar()
-        self.header_printed = False
-        self._print()
-
-    def to_list(self):
-        """Convert to Python nested list."""
-        return [[row[col] for col in self.columns] for row in self.finished_rows]
-
-    def to_numpy(self):
-        """Convert to numpy array."""
-        import numpy as np
-
-        return np.array(self.to_list())
-
-    def to_df(self):
-        """Convert to pandas DataFrame."""
-        import pandas as pd
-
-        return pd.DataFrame(self.to_list(), columns=self.columns)
-
-    def display(self):
-        """Display the whole table. Can be used after closing the table."""
-        if self.header_printed:
-            self.close()
-        self._display_custom(self.to_list())
-
-    def update(self, key, value, *, weight=1):
-        """Update value in the current row."""
-        assert key in self.columns, f"Column '{key}' not in {self.columns}"
-
-        if self._aggregate[key] == "sum":
-            aggr_value = self._new_row[key] if self._aggregate_n[key] > 0 else 0
-            self._new_row[key] = aggr_value + value * weight
-            self._aggregate_n[key] += weight
-
-        elif self._aggregate[key] == "mean":
-            n = self._aggregate_n[key]
-            aggr_value = self._new_row[key] if n > 0 else 0
-            self._new_row[key] = (aggr_value * n + value * weight) / (n + weight)
-            self._aggregate_n[key] += weight
-
-        elif self._aggregate[key] == "max":
-            n = self._aggregate_n[key]
-            aggr_value = self._new_row[key] if n > 0 else -float("inf")
-            self._new_row[key] = max(aggr_value, value)
-            self._aggregate_n[key] += 1
-
-        elif self._aggregate[key] == "min":
-            n = self._aggregate_n[key]
-            aggr_value = self._new_row[key] if n > 0 else float("inf")
-            self._new_row[key] = min(aggr_value, value)
-            self._aggregate_n[key] += 1
-
-        else:
-            self._new_row[key] = value
-
-        t0 = time.time()
-        td = t0 - self._last_time_row_printed
-        if self.print_row_on_update and td > 1 / self.refresh_rate:
-            self._last_time_row_printed = t0
-
-            if not self.progress_bar_active:
-                self._print_row()
-            elif self.embedded_progress_bar:
-                self._refresh_progress_bar()
-
-    def update_from_dict(self, dictionary):
-        """Update multiple values in the current row."""
-        for key, value in dictionary.items():
-            self.update(key, value)
-
-    def _apply_cell_formatting(self, str_value: str, column: str):
-        width = self._widths[column]
-
-        alignment = self._alignment[column]
-        if alignment == "center":
-            str_value = str_value.center(width)
-        elif alignment == "left":
-            str_value = str_value.ljust(width)
-        elif alignment == "right":
-            str_value = str_value.rjust(width)
-        else:
-            allowed_alignments = ["center", "left", "right"]
-            raise KeyError(f"Alignment '{alignment}' not in {allowed_alignments}!")
-
-        clipped = len(str_value) > width
-        str_value = "".join(
-            [
-                " ",  # space at the beginning of the row
-                str_value[:width].center(width),
-                self._symbols.dots if clipped else " ",
-            ]
-        )
-
-        if self._colors[column] is not None:
-            str_value = f"{self._colors[column]}{str_value}{Style.RESET_ALL}"
-        return str_value
-
-    def _bar(self, left: str, center: str, right: str):
-        content_list: List[str] = []
-        for col in self.columns:
-            content_list.append(self._symbols.horizontal * (self._widths[col] + 2))
-
-        center = center.join(content_list)
-        content = ["\r", left, center, right]
-        self._print("".join(content), end="")
-
-    def _bar_custom_center(self, left: str, center: List[str] | str, right: str):
-        """UNUSED"""
-        content_list: List[str] = []
-
-        if isinstance(center, str):
-            center = [center] * (len(self.columns) - 1)
-        assert len(center) == len(self.columns) - 1
-
-        for col in self.columns:
-            content_list.append(self._symbols.horizontal * (self._widths[col] + 2))
-            if center:
-                content_list.append(center.pop(0))
-
-        center = "".join(content_list)
-        content = ["\r", left, center, right]
-        self._print("".join(content), end="")
-
-    def _print_transition_bar(self, previous_n_cols, new_n_cols):
-        """UNUSED"""
-        assert previous_n_cols > 0
-        assert new_n_cols > previous_n_cols
-        added_cols = new_n_cols - previous_n_cols
-
-        symbols = [
-            *([self._symbols.all] * previous_n_cols),
-            *([self._symbols.no_up] * (added_cols - 1)),
-        ]
-        return self._bar_custom_center(left=self._symbols.no_left, center=symbols, right=self._symbols.down_left)
-
-    def _print_top_bar(self):
-        return self._bar(left=self._symbols.down_right, center=self._symbols.no_up, right=self._symbols.down_left)
-
-    def _print_bottom_bar(self):
-        return self._bar(left=self._symbols.up_right, center=self._symbols.no_down, right=self._symbols.up_left)
-
-    def _print_center_bar(self):
-        return self._bar(left=self._symbols.no_left, center=self._symbols.all, right=self._symbols.no_right)
-
-    @staticmethod
-    def _maybe_convert_to_colorama(color):
-        if isinstance(color, str):
-            if hasattr(Fore, color.upper()):
-                return getattr(Fore, color.upper())
-            if hasattr(Style, color.upper()):
-                return getattr(Style, color.upper())
-        return color
-
-    @staticmethod
-    def _check_color(color, color_str=None):
-        if color_str is None:
-            color_str = color
-        assert (
-            color in ALL_COLORS_STYLES
-        ), f"Only colorama colors are allowed, not '{color_str}'! Available: {ALL_COLORS_STYLES_NAMES}"
-
-    def _print_header(self, top=True):
-        assert self.columns, "Columns are required! Use .add_column method or specify them in __init__!"
-
-        self._needs_splitter = False
-
-        if top:
-            self._print_top_bar()
-        else:
-            self._print_center_bar()
-        self._print()
-
-        content = []
-        for column in self.columns:
-            value = self._apply_cell_formatting(column, column)
-            content.append(value)
-        s = "".join(["\r", self._symbols.vertical, self._symbols.vertical.join(content), self._symbols.vertical])
-        self._print(s)
-
-        self._last_header_printed_at_row_count = self.num_rows
-        self.header_printed = True
-        self._print_center_bar()
-        self._print()
-        self._last_row_content = "header"
-
-    def _print_splitter(self):
-        if self._last_row_content == "row":
-            self._print_center_bar()
-            self._print()
-
-            self._needs_splitter = False
-            self._last_row_content = "splitter"
-
-    def _get_row(self):
-        content = []
-        for column in self.columns:
-            value = self._new_row[column]
-            value = self.custom_format(value)
-            value = self._apply_cell_formatting(str_value=str(value), column=column)
-            content.append(value)
-        return "".join(["\r", self._symbols.vertical, self._symbols.vertical.join(content), self._symbols.vertical])
-
-    def _print_row(self):
-        if not self.header_printed:
-            self._print_header(top=True)
-
-        if self.reprint_header_every_n_rows != 0:
-            if self.num_rows - self._last_header_printed_at_row_count >= self.reprint_header_every_n_rows:
-                self._print_header(top=False)
-
-        if self._needs_splitter:
-            self._print_splitter()
-
-        if len(self._new_row) == 0:
-            return
-        self._needs_line_ending = True
-        self._print(self._get_row(), end="")
-
-    def _print_progress_bar(self, i, n, show_before=" ", show_after=" ", embedded=False):
-        i = min(i, n)  # clip the iteration number to be not bigger than the total number of iterations
-        terminal_width = shutil.get_terminal_size(fallback=(0, 0)).columns or float("inf")
-
-        if not embedded:
-            tot_width = sum(self._widths.values()) + 3 * (len(self._widths) - 1) + 2
-            if tot_width >= terminal_width - 1:
-                tot_width = terminal_width - 2
-
-            tot_width = tot_width - len(show_before) - len(show_after)
-            num_hashes = math.ceil(i / n * tot_width)
-            num_empty = tot_width - num_hashes
-
-            self._print(
-                self._symbols.vertical,
-                show_before,
-                self._symbols.pbar_filled * num_hashes,
-                self._symbols.pbar_empty * num_empty,
-                show_after,
-                self._symbols.vertical,
-                end="\r",
-                sep="",
-            )
-        else:
-            row = self._get_row()
-            new_row = []
-            for idx, letter in enumerate(row):
-                if idx / len(row) <= i / n:
-                    if letter == " ":
-                        letter = self._symbols.embedded_pbar_filled
-                new_row.append(letter)
-            row = "".join(new_row)
-            self._print(row, end="\r")
-        sys.stdout.flush()
-
-    def _maybe_line_ending(self):
-        if self._needs_line_ending:
-            self._print()
-            self._needs_splitter = False
-            self._needs_line_ending = False
-            self._last_row_content = "row"
-
-    def _display_custom(self, data):
-        if self.header_printed:
-            self.close()
-
-        for row in data:
-            assert len(row) == len(self.columns)
-            for key, value in zip(self.columns, row):
-                self._new_row[key] = value
-            self._print_row()
-            self.next_row(save=False)
-        self.close()
-        self._last_row_content = "close"
-
-    def _print(self, *args, **kwds):
-        for file in self.files:
-            print(*args, **kwds, file=file)
-
-    def __call__(self, iterator, *range_args, length=None, prefix="", show_throughput=None, show_progress=None):
-        """Display progress bar over the iterator. Try to figure out the iterator length."""
-        global ITERATOR_LENGTH_UNKNOWN_WARNED_ONCE, ITERATOR_LENGTH_CACHE
-
-        if not self.header_printed:
-            self._print_header()
-
-        if show_throughput is None:
-            show_throughput = self.default_show_throughput
-        if show_progress is None:
-            show_progress = self.default_show_progress
-
-        if isinstance(iterator, int):
-            iterator = range(iterator, *range_args)
-        else:
-            assert len(range_args) == 0, "Unnamed args are not allowed here!"
-
-        if length is None and not hasattr(iterator, "__len__"):
-            if not ITERATOR_LENGTH_UNKNOWN_WARNED_ONCE:
-                logging.warning("Iterator length is unknown!")
-                ITERATOR_LENGTH_UNKNOWN_WARNED_ONCE = True
-
-            # We have a back-up mechanism in case of unknown-length iterators.
-            # If we progress over the same unknown length iterator more than once,
-            # we will use its length from the previous launch.
-            save_length_to_cache = True
-
-            if id(iterator) in ITERATOR_LENGTH_CACHE:
-                length = ITERATOR_LENGTH_CACHE[id(iterator)]
-            else:
-                length = 1
-        else:
-            save_length_to_cache = False
-            length = length or len(iterator)
-
-        t_last_printed = -float("inf")
-        t_beginning = time.time()
-
-        self.progress_bar_active = True
-
-        idx = 0
-        for idx, element in enumerate(iterator):
-            if time.time() - t_last_printed > 1 / self.refresh_rate:
-                # Reenable here, in case of nested progress bars
-                self.progress_bar_active = True
-
-                self._print(end="\r")
-                s = time.time() - t_beginning
-                throughput = idx / s if s > 0 else 0.0
-
-                full_prefix = [" [", prefix]
-
-                inside_brackets = []
-                if show_throughput:
-                    inside_brackets.append(f"{throughput: <.2f} it/s")
-                if show_progress:
-                    inside_brackets.append(f"{idx}/{length}")
-                inside_brackets = ", ".join(inside_brackets)
-                full_prefix.append(inside_brackets)
-
-                full_prefix.append("] ")
-                full_prefix = "".join(full_prefix)
-                full_prefix = full_prefix if full_prefix != " [] " else " "
-
-                self._refresh_progress_bar = lambda: self._print_progress_bar(
-                    idx,
-                    length,
-                    show_before=full_prefix,
-                    embedded=self.embedded_progress_bar,
-                )
-                self._refresh_progress_bar()
-
-                t_last_printed = time.time()
-            yield element
-        if save_length_to_cache:
-            ITERATOR_LENGTH_CACHE[id(iterator)] = idx
-
-        self.progress_bar_active = False
-        self._print_row()
-
-    def __setitem__(self, key, value):
-        self.update(key, value, weight=1)
-
-    def __getitem__(self, key):
-        assert key in self.columns, f"Column '{key}' not in {self.columns}"
-
-        return self._new_row[key]

progress-table-0.1.27/progress_table/symbols.py

@@ -1,160 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class Symbols:
-    pbar_filled: str
-    pbar_empty: str
-    embedded_pbar_filled: str
-    dots: str
-    horizontal: str
-    vertical: str
-    all: str
-    up_left: str
-    up_right: str
-    down_left: str
-    down_right: str
-    no_left: str
-    no_right: str
-    no_up: str
-    no_down: str
-
-
-@dataclass
-class SymbolsUnicode(Symbols):
-    name = "normal"
-    pbar_filled = "■"
-    pbar_empty = "□"
-    embedded_pbar_filled = "_"
-    dots = "…"
-    horizontal = "─"
-    vertical = "│"
-    all = "┼"
-    up_left = "┘"
-    up_right = "└"
-    down_left = "┐"
-    down_right = "┌"
-    no_left = "├"
-    no_right = "┤"
-    no_up = "┬"
-    no_down = "┴"
-
-
-@dataclass
-class SymbolsUnicodeBare(Symbols):
-    name = "bare"
-    pbar_filled = "■"
-    pbar_empty = "□"
-    embedded_pbar_filled = "_"
-    dots = "…"
-    horizontal = "─"
-    vertical = " "
-    all = "─"
-    up_left = "─"
-    up_right = "─"
-    down_left = "─"
-    down_right = "─"
-    no_left = "─"
-    no_right = "─"
-    no_up = "─"
-    no_down = "─"
-
-
-@dataclass
-class SymbolsUnicodeRound(Symbols):
-    name = "round"
-    pbar_filled = "■"
-    pbar_empty = "□"
-    embedded_pbar_filled = "_"
-    dots = "…"
-    horizontal = "─"
-    vertical = "│"
-    all = "┼"
-    up_left = "╯"
-    up_right = "╰"
-    down_left = "╮"
-    down_right = "╭"
-    no_left = "├"
-    no_right = "┤"
-    no_up = "┬"
-    no_down = "┴"
-
-
-@dataclass
-class SymbolsUnicodeDouble(Symbols):
-    name = "double"
-    pbar_filled = "■"
-    pbar_empty = "□"
-    embedded_pbar_filled = "_"
-    dots = "…"
-    horizontal = "═"
-    vertical = "║"
-    all = "╬"
-    up_left = "╝"
-    up_right = "╚"
-    down_left = "╗"
-    down_right = "╔"
-    no_left = "╠"
-    no_right = "╣"
-    no_up = "╦"
-    no_down = "╩"
-
-
-@dataclass
-class SymbolsUnicodeBold(Symbols):
-    name = "bold"
-    pbar_filled = "■"
-    pbar_empty = "□"
-    embedded_pbar_filled = "_"
-    dots = "…"
-    horizontal = "━"
-    vertical = "┃"
-    all = "╋"
-    up_left = "┛"
-    up_right = "┗"
-    down_left = "┓"
-    down_right = "┏"
-    no_left = "┣"
-    no_right = "┫"
-    no_up = "┳"
-    no_down = "┻"
-
-
-@dataclass
-class SymbolsAscii(Symbols):
-    name = "ascii"
-    pbar_filled = "#"
-    pbar_empty = "."
-    embedded_pbar_filled = "_"
-    dots = "_"
-    horizontal = "-"
-    vertical = "|"
-    all = "+"
-    up_left = "+"
-    up_right = "+"
-    down_left = "+"
-    down_right = "+"
-    no_left = "+"
-    no_right = "+"
-    no_up = "+"
-    no_down = "+"
-
-
-@dataclass
-class SymbolsAsciiBare(Symbols):
-    name = "ascii_bare"
-    pbar_filled = "#"
-    pbar_empty = "."
-    embedded_pbar_filled = "_"
-    dots = "_"
-    horizontal = "-"
-    vertical = " "
-    all = "-"
-    up_left = "-"
-    up_right = "-"
-    down_left = "-"
-    down_right = "-"
-    no_left = "-"
-    no_right = "-"
-    no_up = "-"
-    no_down = "-"