PyLoadBar v0.0.9 development started.

- Overhauled `PyLoadBar` class.
- Replaced "load" method with "start" method.
- Messages and labels are now set when initializing `PyLoadBar` class.
- Total iterations can now be set.
- Iterations now take random amount of time to complete to add realism.
- Min/Max time to complete iteration is set upon calling "start()".
- Re-wrote tests.
- Updated requirements.txt to be less strict.
- Updated "setup.py".

Signed-off-by: schlopp96 <71921821+schlopp96@users.noreply.github.com>

Author: schlopp96

PyLoadBar/main.py

@@ -1,75 +1,143 @@
 #!/usr/bin/env python3
 
-from time import sleep as s
+import sys
+from os import chdir
+from os.path import dirname
+from random import uniform
+from time import sleep
 
 import tqdm
 
-__version__ = '0.0.8'
+sys.path.insert(0, dirname(
+    dirname(__file__)))  # Ensure module can be found by Python.
+
+chdir(dirname(__file__))  # Change working directory to main module.
+
+__version__ = '0.0.9'
 
 
 class PyLoadBar:
-    """Create simple loading sequences with ability to customize start/finish messages, toggle visual progress meter, and set time to completion."""
+    """Generate loading sequences with ability to customize start/finish messages, toggle visual progress meter, and set time to completion.
 
-    def __init__(self):
-        pass
+    ---
 
-    def load(self,
-                 msg_loading: str = 'Loading',
-                 msg_complete: str = 'Done!',
-                 time: int = 5,
-                 label: str = None,
-                 enable_display: bool = True) -> None:
-        """
-        Start a loading sequence which includes start/completion messages, and an optional progress meter.
+    Settings:
+
+        - Set custom start/completion messages by passing string to `msg_loading` and `msg_complete` respectively.
+
+        - Toggle visual progress meter using `enable_display`.
+
+        - Apply label to progress meter by passing string to `label: str | None` (set to `None` by default)
+                - Note that `enable_display: bool` must be set to `True` for this to take effect.
+
+        - When calling :func:`start`:
+
+            - Optionally set the total number of iterations to run using `iter_total: int`
 
-        - User may set custom start/completion messages using the parameters `msg_loading: str` and `msg_complete: str` respectively.
-        - Set the sequence length in milliseconds using the `time: int` parameter.
-            - Each unit of time = 0.1 seconds.
-        - Display of the progress meter is activated by default, but may be disabled using the `enable_display` parameter.
-        - The progress meter may be labeled using the `label: str` parameter (set to `None` by default).
-            - Note that `enable_display` must be set to `True` for this to take effect.
+            - Optionally set the minimum/maximum iteration length in seconds using the `min_iter: float` and `max_iter: float` parameters respectively
+                - Default values are `min_iter: 0.1` seconds and `max_iter: 1.0` seconds
 
-        Examples:
+    """
 
-            - Load sequence WITH progress meter (default):
+    def __init__(self,
+                 msg_loading: str | None = 'Loading...',
+                 msg_complete: str | None = 'Done!',
+                 label: str | None = None,
+                 enable_display: bool = True):
+        """Initialize loading sequence with set configuration.
 
-                >>> bar_ON = PyLoadBar() # < Create class instance.
-                >>> bar_ON.load(msg_loading='Printing', msg_complete='Complete!', time=50) # <- Will take 5 seconds to complete loading sequence.
+        ---
+
+        :param msg_loading: initial loading message string, defaults to 'Loading...'
+        :type msg_loading: :class:`str` | None, optional
+        :param msg_complete: final message string displayed upon completion, defaults to 'Done!'
+        :type msg_complete: :class:`str` | None, optional
+        :param label: label displayed alongside progress bar, defaults to None
+        :type label: :class:`str` | None, optional
+        :param enable_display: toggle visible progress meter, defaults to True
+        :type enable_display: :class:`bool`, optional
+        """
+
+        self.msg_loading: str | None = msg_loading
+        self.msg_complete: str | None = msg_complete
+        self.label: str | None = label
+        self.enable_display: bool = enable_display
 
-            - Load sequence WITHOUT progress meter:
+    def start(
+        self,
+        iter_total: int = 5,
+        min_iter: float = 0.1,
+        max_iter: float = 1.0,
+    ) -> None:
+        """Start loading sequence.
 
-                >>> bar_OFF = PyLoadBar() # < Create class instance.
-                >>> bar_OFF.load('Processing Information', 'Finished!', time=20, enable_display=False) # <- Will take 2 seconds to complete loading sequence.
+        ---
+
+        - Set the total number of iterations using the `iter_total: int` parameter
+
+        - Set the minimum/maximum iteration length in seconds using the `min_iter: float` and `max_iter: float` parameters respectively
+            - Default values are `min_iter: 0.1` seconds and `max_iter: 1.0` seconds
 
         ---
 
-        :param msg_loading: message to display during loading process, defaults to `"Loading"`.
-        :type msg_loading: str, optional
-        :param msg_complete: message to display upon load completion, defaults to `"Done!"`.
-        :type msg_complete: str, optional
-        :param time: time for loading sequence to complete measured in units of 0.1 seconds, defaults to `5`.
-        :type time: int, optional
-        :param label: label preceding progress bar, defaults to `None`.
-        :type label: str, optional
-        :param enable_display: toggle display of progress bar during loading process, defaults to `True`.
-        :type enable_display: bool, optional
-        :return: loading sequence.
-        :rtype: None
+        :param iter_total: number of iter_total until completion, defaults to 5
+        :type iter_total: :class:`int`, optional
+        :param min_iter: minimum possible time to complete an iteration, defaults to 1
+        :type min_iter: :class:`int`, optional
+        :param max_iter: maximum possible time to complete an iteration, defaults to 5
+        :type max_iter: :class:`int`, optional
+        """
+
+        if self.enable_display:
+            return self.__loadseq_A(iter_total, min_iter, max_iter)
+
+        else:
+            return self.__loadseq_B(iter_total)
+
+    def __loadseq_A(self, iter_total: int, min_iter: float,
+                    max_iter: float) -> None:
+        """
+        Run loading sequence and display progress with graphical progress bar.
+
+        :param iter_total: total number of iter_total to run
+        :type iter_total: :class:`int`
+        :param min_iter: minimum possible time (in seconds) an iteration can take
+        :type min_iter: :class:`float`
+        :param max_iter: maximum possible time (in seconds) an iteration can take
+        :type max_iter: :class:`float`
+        """
+
+        print(f'\n{self.msg_loading}\n')
+
+        for iter in tqdm.trange(iter_total, desc=self.label):
+            sleep(uniform(min_iter, max_iter))
+            iter -= 1
+
+        print(f'\n{self.msg_complete}\n')
+
+        # Add a small delay to allow user to see completion message.
+        sleep(0.5)
+
+    def __loadseq_B(self, iter_total: int) -> None:
+        """
+        Run non-graphical loading sequence.
+
+        :param iter_total: Amount of iter_total to run loading sequence
+        :type iter_total: :class:`int`
+        :return: nonvisual loading sequence
+
         """
 
-        match enable_display:
-            case True:
-                print(f'{msg_loading}...\n')
-                for iter in tqdm.trange(time, desc=label):
-                    s(0.1)
-                    iter -= 1
-                print(f'\n{msg_complete}')
-
-            case False:
-                print(f'{msg_loading}', end='')
-                for iter in range(time):
-                    print('.', end='')
-                    s(0.1)
-                    iter -= 1
-                print(f'\n\n{msg_complete}')
-        s(0.5) # Add a small delay to allow user to see completion message.
+        print(f'\n{self.msg_loading}', end='')
+
+        for iter in range(iter_total):
+            for _ in range(3):
+                print('.', end='')
+                sleep(0.3)
+            print('\b\b\b', end='')
+            iter -= 1
+
+        print(f'\n\n{self.msg_complete}\n')
+
+        # Add a small delay to allow user to see completion message.
+        sleep(0.5)

PyLoadBar/tests/PyLoadBar_test.py

@@ -1,22 +1,25 @@
-from PyLoadBar.main import PyLoadBar
+from ..main import PyLoadBar
+
 
 
 def test_loadA():
     bar = PyLoadBar()
-    assert bar.load(time=1, enable_display=False) is None
+    assert bar.start() is None
 
 
 def test_loadB():
-    bar = PyLoadBar()
-    assert bar.load("Taking sweet time",
-                    "Finally...\n\nTook long enough.") is None
+    bar = PyLoadBar("Taking sweet time",
+                    "Finally...\n\nTook long enough.", enable_display=False)
+    assert bar.start(iter_total=3) is None
 
 
 def test_loadC():
-    bar = PyLoadBar()
-    assert bar.load('Exiting', 'Finished!!', enable_display=False) is None
+    bar = PyLoadBar('Exiting', 'Finished!!')
+    assert bar.start() is None
 
 
 def test_loadD():
-    bar = PyLoadBar()
-    assert bar.load(4, 3463463.4, time=3, enable_display=False) is None
+    bar = PyLoadBar(
+        4,
+        3463463.4)
+    assert bar.start(min_iter=0.3, max_iter=0.05) is None

requirements.txt

@@ -1,2 +1,2 @@
-setuptools==62.1.0
-tqdm==4.64.0
+setuptools>=62.1.0
+tqdm>=4.64.0

setup.py

@@ -7,8 +7,9 @@
 
 setup(
     name='PyLoadBar',
-    version="0.0.8",
-    description='Simple, easy-to-use loading sequence/progress bar module.',
+    version="0.0.9",
+    description=
+    'Easy-to-use loading sequence/progress bar generator, enabling users to customize start/finish messages, toggle visual progress meter, set amount of iterations, among other features.',
     url='https://github.com/schlopp96/PyLoadBar',
     author='schlopp96',
     author_email='schloppdaddy@gmail.com',
@@ -20,16 +21,14 @@
     install_requires=[reqs],
     extras_require={"dev": ["pytest>=6.2.5"]},
     classifiers=[
-        "Development Status :: 3 - Alpha",
-        "Intended Audience :: Developers",
+        "Development Status :: 3 - Alpha", "Intended Audience :: Developers",
         "Intended Audience :: End Users/Desktop",
         "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
         "Natural Language :: English",
         "Operating System :: Microsoft :: Windows",
         "Programming Language :: Python :: 3",
         "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Topic :: Utilities"
+        "Programming Language :: Python :: 3.10", "Topic :: Utilities"
     ],
     keywords=[
         'python, load, bar, loading, sequence, progress, simple, easy, utilities, package, module, tqdm, pytest, pyloadbar, developer, tool, tqdm'