v0.2.0 update initial commit

---

- Changed param `txt_seq_speed` to `txt_iter_speed`.
- Improvements to docstrings.
- Fixed "shutter" effect when using text-sequence.
  - No longer clears entire line each iteration.
- Improved tests.
- Removed project contribution PyPI install option.
- Improved reqs compatibility.
- Improvements to "./README.md".
- Added "./assets" directory to contain extra "./README.md" files.
- Added gifs to "./README.md".

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

Author: schlopp96

PyLoadBar/main.py

@@ -10,29 +10,29 @@
 sys.path.insert(0, dirname(
     dirname(__file__)))  # Ensure module can be found by Python.
 
-__version__ = '0.1.1'
+__version__ = '0.2.0'
 
 
 class PyLoadBar:
-    """Generate loading sequences with ability to customize start/finish messages, toggle visual progress meter, and set time to completion.
+    """Create loading sequences with ability to customize start/finish messages, toggle between bar/text progress sequences, and set length of progress sequences.
 
     ---
 
     Settings:
 
         - When instantiating a new :class:`PyLoadBar` object, you can set the sequence type using :param:`bar_sequence`.
 
-        - When calling :func:`start(self, msg_loading, msg_complete, label, iter_total, min_iter, max_iter, txt_seq_speed)`:
+        - When calling :func:`self.start(self, msg_loading, msg_complete, label, iter_total, min_iter, max_iter, txt_iter_speed)`:
             - Set custom start/completion messages by passing string to :param:`msg_loading` and :param:`msg_complete` respectively.
-            - Optionally set the total number of iterations to run using :param:`iter_total`, defaults to 5.
+            - Optionally set the total number of iterations to run using :param:`iter_total`, defaults to `5`.
 
             - If using bar-sequence:
                 - Set the minimum/maximum iteration length in seconds using the :param:`min_iter` and :param:`max_iter` parameters respectively.
                     - Time taken by each individual iteration is randomized within range of :param:`min_iter` and :param:`max_iter`.
                 - Apply label to progress meter by passing string to :param:`label` (set to `None` by default).
 
             - If using text-sequence:
-                - Set number of seconds to complete a single text-sequence iteration using :param:`txt_seq_speed`.
+                - Set number of seconds to complete a single text-sequence iteration using :param:`txt_iter_speed`.
                     - Defaults to `0.5` seconds per iteration/animation cycle.
     """
 
@@ -44,7 +44,7 @@ def __init__(self, bar_sequence: bool = True) -> None:
         :param bar_sequence: toggle progress-bar loading sequence, defaults to `True`
         :type bar_sequence: :class:`bool`, optional
         :return: :class:`PyLoadBar` object
-        :rtype: None
+        :rtype: `None`
         """
 
         self.bar_sequence: bool = bar_sequence
@@ -57,7 +57,7 @@ def start(
         iter_total: int = 5,
         min_iter: float = 0.01,
         max_iter: float = 0.5,
-        txt_seq_speed: float = 0.5,
+        txt_iter_speed: float = 0.5,
     ) -> None:
         """Start loading sequence.
 
@@ -69,36 +69,36 @@ def start(
                 - Note that :param:`bar_sequence` must be set to `True` for this to take effect.
 
             - Set the total number of iterations to complete using the :param:`iter_total`.
-                - Defaults to 5 iterations.
+                - Defaults to `5` iterations.
 
             - If using bar-sequence:
                 - Set the minimum/maximum iteration length in seconds using the :param:`min_iter` and :param:`max_iter` parameters respectively.
                     - Time taken by each individual iteration is randomized within range of :param:`min_iter` and :param:`max_iter`.
-                        - :param:`min_iter` defaults to 0.01 seconds, :param:`max_iter` defaults to 0.5 seconds.
+                        - :param:`min_iter` defaults to `0.01` seconds, :param:`max_iter` defaults to `0.5` seconds.
                 - Apply label to progress meter by passing string to :param:`label` (set to `None` by default).
 
             - If using text-sequence:
-                - Set number of seconds to complete a single text-sequence iteration using :param:`txt_seq_speed`.
+                - Set number of seconds to complete a single text-sequence iteration using :param:`txt_iter_speed`.
                     - Defaults to `0.5` seconds per iteration/animation cycle.
 
         ---
 
         :param msg_loading: initial loading message, defaults to 'Loading'
-        :type msg_loading: :class:`str` | None, optional
+        :type msg_loading: :class:`str` | `None`, optional
         :param msg_complete: final message 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 iter_total: total amount of iterations to run, defaults to 5
+        :type msg_complete: :class:`str` | `None`, optional
+        :param label: label displayed alongside progress bar, defaults to `None`
+        :type label: :class:`str` | `None`, optional
+        :param iter_total: total amount of iterations to run, defaults to `5`
         :type iter_total: :class:`int`, optional
-        :param min_iter: minimum possible time to complete an iteration, defaults to 0.01 seconds
+        :param min_iter: minimum possible time to complete an iteration, defaults to `0.01` seconds
         :type min_iter: :class:`float`, optional
-        :param max_iter: maximum possible time to complete an iteration, defaults to 0.5 seconds
+        :param max_iter: maximum possible time to complete an iteration, defaults to `0.5` seconds
         :type max_iter: :class:`float`, optional
-        :param txt_seq_speed: number of seconds to complete a single text-sequence iteration, defaults to 0.5 seconds
-        :type txt_seq_speed: :class:`float`, optional
+        :param txt_iter_speed: number of seconds to complete a single text-sequence iteration (only usable if :param:`self.bar_sequence` == :bool:`False`), defaults to `0.5` seconds
+        :type txt_iter_speed: :class:`float`, optional
         :return: loading sequence
-        :rtype: None
+        :rtype: `None`
         """
 
         if self.bar_sequence and msg_loading == 'Loading':
@@ -111,7 +111,7 @@ def start(
 
             else:
                 self.__text_seq(msg_loading, msg_complete, iter_total,
-                                txt_seq_speed)
+                                txt_iter_speed)
 
             sleep(
                 0.5
@@ -137,7 +137,7 @@ def __bar_seq(msg_loading: str | None, msg_complete: str | None,
 
             Loading...
 
-            Progress: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████▊| 5/5]
+            Progress: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████▊| [5/5]
 
             Done!
 
@@ -146,19 +146,19 @@ def __bar_seq(msg_loading: str | None, msg_complete: str | None,
         ---
 
         :param msg_loading: initial loading message
-        :type msg_loading: :class:`str` | None
+        :type msg_loading: :class:`str` | `None`
         :param msg_complete: final message displayed upon completion
-        :type msg_complete: :class:`str` | None
+        :type msg_complete: :class:`str` | `None`
         :param label: label displayed alongside progress bar
-        :type label: :class:`str` | None
+        :type label: :class:`str` | `None`
         :param iter_total: total amount of iterations 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`
         :return: Loading sequence with graphical progress bar.
-        :rtype: None
+        :rtype: `None`
         """
 
         print(f'{msg_loading}\n')
@@ -167,15 +167,15 @@ def __bar_seq(msg_loading: str | None, msg_complete: str | None,
         for iter in tqdm.trange(
                 iter_total,
                 desc=label,
-                bar_format='{l_bar}{bar}| {n_fmt}/{total_fmt}]'):
+                bar_format='{l_bar}{bar}| [{n_fmt}/{total_fmt}]'):
             sleep(uniform(min_iter, max_iter))
             iter -= 1
 
         print(f'\n{msg_complete}\n')  # Print completion message.
 
     @staticmethod
     def __text_seq(msg_loading: str | None, msg_complete: str | None,
-                   iter_total: int, iter_speed: float) -> None:
+                   iter_total: int, txt_iter_speed: float) -> None:
         """Run text-based loading sequence.
 
         ---
@@ -184,14 +184,14 @@ def __text_seq(msg_loading: str | None, msg_complete: str | None,
 
         ```python
             >>> bar = PyLoadBar(bar_sequence=False) # Initialize loading sequence.
-            >>> bar.start(msg_loading='Loading', msg_complete='Done!', iter_total=1, txt_seq_speed=1) # Start loading sequence.
+            >>> bar.start(msg_loading='Loading', msg_complete='Done!', iter_total=1, txt_iter_speed=1) # Start loading sequence.
             >>> # Note that during actual use case, text is printed to same line followed by an animated '.' character sequence:
 
             # Would look like:
-                It(1) line 1: \r"Loading"
-                It(2) line 1: \r"Loading."
-                It(3) line 1: \r"Loading.."
-                It(4) line 1: \r"Loading..."
+                It(1) line 1: "Loading"
+                It(2) line 1: "Loading."
+                It(3) line 1: "Loading.."
+                It(4) line 1: "Loading..."
 
                 Repeat(...)
 
@@ -203,26 +203,28 @@ def __text_seq(msg_loading: str | None, msg_complete: str | None,
         ---
 
         :param msg_loading: initial loading message
-        :type msg_loading: :class:`str` | None
+        :type msg_loading: :class:`str` | `None`
         :param iter_total: number of iterations to run during loading sequence
         :type iter_total: :class:`int`
-        :param iter_speed: number of seconds to complete a single text-sequence iteration
-        :type iter_speed: :class:`float`
+        :param txt_iter_speed: number of seconds to complete a single text-sequence iteration
+        :type txt_iter_speed: :class:`float`
         :return: animated text-based progress sequence
-        :rtype: None
+        :rtype: `None`
         """
 
         # Start text animation.
         for iter in range(iter_total):
             print(f'{msg_loading}', end='', flush=True)
-            sleep(iter_speed / 4)
+            sleep(txt_iter_speed / 4)
 
-            for _ in range(3):  # Add 3 dots to `msg_loading` message.
+            for _ in range(3):  # Add ellipsis to `msg_loading` message
                 print('.', end='', flush=True)
-                sleep(iter_speed / 4)
+                sleep(txt_iter_speed / 4)
 
-            print('\x1b[2K\r', end='', flush=True)  # Clear line.
+            print('\b\b\b\033[K\r', end='',
+                  flush=True)  # Erase ellipsis from previous iteration.
 
             iter -= 1
 
-        print(f'\n{msg_complete}\n')  # Print completion message.
+        print(f'\x1b[2K\r{msg_complete}\n'
+              )  # Clear line and print completion message.

PyLoadBar/tests/PyLoadBar_test.py

@@ -1,33 +1,35 @@
-from ..main import PyLoadBar
+from PyLoadBar.main import PyLoadBar
 
 
-def test_seqA():
+def test_default_bar():
     seq = PyLoadBar()
     assert seq.start() is None
 
 
-def test_seqB():
+def test_default_text():
     seq = PyLoadBar(bar_sequence=False)
     assert seq.start() is None
 
 
-def test_seqC():
+def test_bar_params():
     seq = PyLoadBar()
-    assert seq.start(msg_loading='TEST',
-                    msg_complete='COMPLETE',
-                    label="LOADING", iter_total=25, min_iter=0.001, max_iter=0.25) is None
+    assert seq.start(msg_loading='STARTED TEST',
+                     msg_complete='COMPLETE',
+                     label="TESTING",
+                     iter_total=25,
+                     min_iter=0.001,
+                     max_iter=0.25) is None
 
 
-def test_seqD():
-    seq = PyLoadBar(bar_sequence=False,
-                    )
+def test_text_params():
+    seq = PyLoadBar(bar_sequence=False, )
     assert seq.start(msg_loading='TEST',
                      msg_complete='COMPLETE',
                      iter_total=5,
-                     txt_seq_speed=0.25) is None
+                     iter_speed=0.25) is None
 
 
-def test_seqE():
+def test_numbers_in_message_params():
     seq = PyLoadBar()
     assert seq.start(
         4, 3463463.4, label=123, iter_total=5, min_iter=0.001,

README.md

@@ -1,6 +1,6 @@
 # PyLoadBar
 
-> _**Customizeable loading sequence/progress bar generator, enabling users to customize start/finish messages, toggle sequence type, and set total iterations among other features.**_
+> _**Loading sequence/progress bar generator with options for users to customize start/finish messages, toggle between bar/text sequences, and set total iterations among other features.**_
 
 ---
 
@@ -34,7 +34,7 @@
     - e.g. `start(min_iter=0.5, max_iter=1.5)` would take anywhere between 0.5 - 1.5 seconds to complete a single iteration.
 
 - The _text-based_ loading sequence displays the loading message followed by incrementing dots, all printed to the same line.
-  - Set number of seconds to complete a single text-sequence iteration using `txt_seq_speed: float`.
+  - Set number of seconds to complete a single text-sequence iteration using `txt_iter_speed: float`.
     - Defaults to `0.5` seconds per animation cycle.
 
 ---
@@ -96,13 +96,10 @@ gh repo clone schlopp96/PyLoadBar
 
     >>> important_bar.start(msg_loading='Important Stuff Happening', msg_complete='Day Saved!', label='Saving Day', min_iter=0.05, max_iter=1.0, iter_total=10) # Call `start` method to begin loading sequence.
 
-    Important Stuff Happening...
-
-    Saving Day: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 10/10
-
-    Day Saved!
   ```
 
+    ![alt](./assets/bar_sequence.gif)
+
 - Example of animated-text-based loading sequence:
 
   ```python
@@ -112,25 +109,9 @@ gh repo clone schlopp96/PyLoadBar
 
     >>> bar.start(msg_loading='Loading', msg_complete='Done!', iter_total=1, txt_iter_speed=1) # Start animated-text loading sequence.
 
-    # Note that during actual use case, text is printed to same line followed by incrementing dots:
-
-    Loading
-    Loading.
-    Loading..
-    Loading...
-
-    Done!
   ```
 
----
-
-## Contributing to PyLoadBar
-
-- If you wish to help contribute to this project, please run the following in your virtual env to acquire the necessary dependencies and tools you need to develop and run tests:
-
-  ```shell
-    pip install PyLoadBar[dev]
-  ```
+    ![alt](./assets/text_sequence.gif)
 
 ---
 

assets/bar_sequence.gif

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

assets/text_sequence.gif

@@ -7,7 +7,7 @@
 
 setup(
     name='PyLoadBar',
-    version="0.1.1",
+    version="0.2.0",
     description=
     'Customizeable loading sequence/progress bar generator, enabling users to customize start/finish messages, toggle sequence type, and set total iterations among other features.',
     url='https://github.com/schlopp96/PyLoadBar',
@@ -19,7 +19,6 @@
     packages=find_packages(),
     include_package_data=True,
     install_requires=[reqs],
-    extras_require={"dev": ["pytest>=6.2.5"]},
     classifiers=[
         "Development Status :: 3 - Alpha", "Intended Audience :: Developers",
         "Intended Audience :: End Users/Desktop",
@@ -31,5 +30,5 @@
         "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'
+        'python, load, bar, loading, sequence, progress, progress-bar, simple, easy, utilities, package, module, tqdm, pyloadbar, developer, tool'
     ])