Progress Tracking

class Counter:
    def __init__(self, **kwargs):
        """
        Progress counter with optional progress bar display.

        Parameters:
        - total: Total expected count (enables progress bar mode)
        - desc: Description text displayed before counter
        - unit: Unit label for rate calculations and display
        - count: Starting count value (default: 0)
        - enabled: Counter status (default: True)
        - manager: Manager instance (auto-created if None)
        - stream: Output stream (passed to auto-created manager)
        - color: Progress bar color (str or RGB tuple)
        - bar_format: Custom format string for progress bars
        - counter_format: Custom format string for simple counters
        - all_fields: Populate rate, interval, eta fields in subcounters (default: False)
        - fill: Fill character for counter_format (default: ' ')
        - fields: Additional user-defined fields for formatting (dict)
        - leave: Leave counter visible after closing (default: True)
        - min_delta: Minimum time between refreshes in seconds (default: 0.1)
        - offset: Number of non-printable characters to account for
        - series: Progression series characters for progress bar
        - **kwargs: Additional user-defined fields
        """

    def update(self, incr=1, force=False):
        """
        Update the counter by the specified increment.

        Parameters:
        - incr: Amount to increment count (default: 1)
        - force: Force refresh even if min_delta not reached (default: False)
        """

    def close(self, clear=False):
        """
        Close the counter and clean up display.

        Parameters:
        - clear: Remove counter from display (default: False)
        """

    def refresh(self, flush=True, elapsed=None):
        """
        Refresh counter display with current values.

        Parameters:
        - flush: Flush output streams (default: True)
        - elapsed: Override elapsed time calculation
        """

    def add_subcounter(self, color, count=0, all_fields=None):
        """
        Add a subcounter for multicolored progress segments.

        Parameters:
        - color: Color for this segment (str or RGB tuple)
        - count: Initial count for subcounter (default: 0)
        - all_fields: Include rate, interval, eta fields (default: None, uses parent setting)

        Returns:
        SubCounter instance
        """

    def format(self, width=None, elapsed=None):
        """
        Format counter for display.

        Parameters:
        - width: Width in columns to make progress bar
        - elapsed: Time since started. Automatically determined if None

        Returns:
        str: Formatted progress bar or counter
        """

    def clear(self, flush=True):
        """
        Clear counter display.

        Parameters:
        - flush: Flush output streams (default: True)
        """

    def reset(self):
        """
        Reset counter to its initial state.
        
        Resets count to initial value and clears all subcounters.
        """

    def __enter__(self):
        """Context manager entry. Returns self."""

    def __exit__(self, *args):
        """Context manager exit. Calls close()."""

    def __call__(self, iterable):
        """
        Iterate over iterable, updating counter for each item.

        Parameters:
        - iterable: Iterable to process

        Returns:
        Generator yielding items from iterable
        """

    @property
    def count(self):
        """Current count value."""

    @property
    def elapsed(self):
        """Elapsed time since counter creation."""

    @property
    def rate(self):
        """Current rate (count per second)."""

    @property
    def subcount(self):
        """Total count from all subcounters."""

class SubCounter:
    def __init__(self, parent, color=None, count=0, all_fields=False):
        """
        Child counter for multicolored progress bar segments.

        Parameters:
        - parent: Parent Counter instance
        - color: Segment color (str or RGB tuple)
        - count: Initial count (default: 0)
        - all_fields: Calculate rate, interval, eta fields (default: False)
        """

    def update(self, incr=1, force=False):
        """
        Update the subcounter and trigger parent refresh.

        Parameters:
        - incr: Amount to increment (default: 1)
        - force: Force refresh even if min_delta not reached
        """

    def update_from(self, source, incr=1, force=False):
        """
        Transfer count from another counter to this subcounter.

        Parameters:
        - source: Source Counter or SubCounter to transfer from
        - incr: Amount to transfer (default: 1)
        - force: Force refresh even if min_delta not reached
        
        Source must be the parent Counter or a peer SubCounter.
        """

    @property
    def count(self):
        """Current subcounter count."""

    @property
    def parent(self):
        """Parent Counter instance."""

import enlighten
import time

# Create a progress bar with known total
pbar = enlighten.Counter(total=100, desc='Processing', unit='items')

for i in range(100):
    time.sleep(0.1)  # Simulate work
    pbar.update()

pbar.close()

import enlighten
import time

# Create a counter without total (no progress bar)
counter = enlighten.Counter(desc='Processed', unit='records')

for i in range(50):
    time.sleep(0.2)
    counter.update()

counter.close()

import enlighten

# Custom progress bar format
pbar = enlighten.Counter(
    total=100,
    desc='Custom',
    unit='ops',
    bar_format='{desc}{desc_pad}{percentage:3.0f}%|{bar}| {count}/{total} [{elapsed}<{eta}]'
)

# Custom counter format
counter = enlighten.Counter(
    desc='Events',
    unit='evt',
    counter_format='{desc}{desc_pad}{count} {unit} [{elapsed}, {rate:.1f}/s]{fill}'
)

import enlighten
import time

# Create main progress bar
pbar = enlighten.Counter(total=100, desc='Multi-colored', unit='items')

# Add colored segments
red_sub = pbar.add_subcounter('red')
green_sub = pbar.add_subcounter('green')
blue_sub = pbar.add_subcounter('blue')

# Update different segments
for i in range(100):
    if i < 40:
        red_sub.update()
    elif i < 70:
        green_sub.update()
    else:
        blue_sub.update()
    time.sleep(0.1)

pbar.close()

import enlighten

# Counter with all options
pbar = enlighten.Counter(
    total=1000,
    desc='Advanced Progress',
    unit='items',
    initial=50,                    # Start at 50
    color='blue',                  # Bar color
    justify=enlighten.Justify.CENTER,  # Center description
    leave=True,                    # Keep visible after completion
    min_delta=0.5,                 # Minimum time between updates
    offset=2,                      # Display position offset
    additional_fields={'stage': 'Processing'}  # Custom fields
)

# Update with custom increments
pbar.update(10)  # Add 10 to count
pbar.update(5)   # Add 5 more

# Force refresh regardless of min_delta
pbar.update(0, force=True)

import enlighten
import time

# Use manager for multiple bars
manager = enlighten.get_manager()

# Create multiple progress bars
download_bar = manager.counter(total=100, desc='Downloading', unit='MB')
process_bar = manager.counter(total=50, desc='Processing', unit='files')

# Simulate concurrent operations
for i in range(100):
    download_bar.update()
    if i % 2 == 0:
        process_bar.update()
    time.sleep(0.1)

manager.stop()