flexibleloop 0.1.0__tar.gz

flexibleloop-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tolgakanatli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flexibleloop-0.1.0/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: flexibleloop
+Version: 0.1.0
+Summary: A flexible, customizable while loop for Python with timeout, iteration limits, and pre-iteration hooks.
+Author-email: "Dr. Tolga Kaan Kanatlı" <tolgakanatli@hotmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 tolgakanatli
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/tolgakanatli/flexibleloop
+Keywords: loop,while,timeout,iteration,utility
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# flexibleloop
+
+A Python utility that extends the standard `while` loop with built-in timeout control, iteration limits, pre-iteration hooks, and dynamic condition functions — all through a clean `for`-loop interface.
+
+---
+
+## Why
+
+Python's `while` loop is simple but limited. Adding a timeout, counting iterations, or updating variables before checking a condition requires boilerplate every time. `FlexibleWhile` packages all of that into a reusable, configurable object.
+
+---
+
+## Features
+
+- **Timeout** — Stop the loop automatically after a set number of seconds
+- **Max iterations** — Cap the number of iterations without a counter variable
+- **Before function** — Run a function before each iteration; its return value becomes the loop variable
+- **Condition function** — Define the loop condition as a callable instead of inline logic
+- **Callbacks** — Execute custom functions when timeout or max iterations are hit
+- **Clean interface** — Used as a standard `for` loop; no new syntax to learn
+
+---
+
+## Installation
+
+Clone the repository and import directly:
+
+```bash
+git clone https://github.com/tolgakanatli/flexiblewhile.git
+```
+
+```python
+from FlexibleLoop import FlexibleWhile
+```
+
+---
+
+## Usage
+
+### Basic loop with timeout
+
+```python
+from FlexibleLoop import FlexibleWhile
+
+loop = FlexibleWhile(timeout=5.0)
+
+for _ in loop:
+    # Runs until 5 seconds have elapsed
+    do_something()
+```
+
+### Loop with a condition function
+
+```python
+def condition(value):
+    return value < 100
+
+def update(value):
+    return value + 7
+
+loop = FlexibleWhile(
+    before_func=update,
+    cond_func=condition,
+    start_vals=(0,)
+)
+
+for value in loop:
+    print(value)
+# Prints: 7, 14, 21, ... up to 98
+```
+
+### Loop with max iterations and a callback
+
+```python
+def on_limit():
+    print("Max iterations reached")
+
+loop = FlexibleWhile(
+    max_iterations=10,
+    on_max_iterations=on_limit
+)
+
+for _ in loop:
+    do_something()
+```
+
+### Accessing loop metadata
+
+```python
+loop = FlexibleWhile(timeout=3.0)
+for _ in loop:
+    pass
+
+print(f"Completed {loop.iterations} iterations in {loop.time_elapsed:.2f}s")
+```
+
+---
+
+## API Reference
+
+### `FlexibleWhile(before_func, cond_func, start_vals, timeout, max_iterations, on_timeout, on_max_iterations)`
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `before_func` | callable | None | Called before each iteration. Return value updates loop variable(s). |
+| `cond_func` | callable | None | Loop continues while this returns `True`. `None` is equivalent to `while True`. |
+| `start_vals` | tuple | `(None,)` | Initial values passed to `before_func` and `cond_func` on first iteration. |
+| `timeout` | float | None | Maximum loop duration in seconds. |
+| `max_iterations` | int | None | Maximum number of iterations. |
+| `on_timeout` | callable | None | Called when timeout is reached. |
+| `on_max_iterations` | callable | None | Called when max iterations is reached. |
+
+### Instance attributes (after iteration)
+
+| Attribute | Description |
+|---|---|
+| `loop.iterations` | Number of completed iterations |
+| `loop.time_elapsed` | Total elapsed time in seconds |
+| `loop.values` | Current value(s) of the loop variable |
+
+---
+
+## License
+
+MIT License — free to use, modify, and distribute, including commercially.  
+Attribution required: please credit **Dr. Tolga Kaan Kanatlı** in any derivative work or product.
+
+---
+
+## Author
+
+**Dr. Tolga Kaan Kanatlı**  
+PhD in Chemical Engineering — PEM Fuel Cells & Hydrogen Production  
+[GitHub](https://github.com/tolgakanatli) · [LinkedIn](https://www.linkedin.com/in/tolgakanatli) · tolgakanatli@hotmail.com

flexibleloop-0.1.0/README.md

@@ -0,0 +1,134 @@
+# flexibleloop
+
+A Python utility that extends the standard `while` loop with built-in timeout control, iteration limits, pre-iteration hooks, and dynamic condition functions — all through a clean `for`-loop interface.
+
+---
+
+## Why
+
+Python's `while` loop is simple but limited. Adding a timeout, counting iterations, or updating variables before checking a condition requires boilerplate every time. `FlexibleWhile` packages all of that into a reusable, configurable object.
+
+---
+
+## Features
+
+- **Timeout** — Stop the loop automatically after a set number of seconds
+- **Max iterations** — Cap the number of iterations without a counter variable
+- **Before function** — Run a function before each iteration; its return value becomes the loop variable
+- **Condition function** — Define the loop condition as a callable instead of inline logic
+- **Callbacks** — Execute custom functions when timeout or max iterations are hit
+- **Clean interface** — Used as a standard `for` loop; no new syntax to learn
+
+---
+
+## Installation
+
+Clone the repository and import directly:
+
+```bash
+git clone https://github.com/tolgakanatli/flexiblewhile.git
+```
+
+```python
+from FlexibleLoop import FlexibleWhile
+```
+
+---
+
+## Usage
+
+### Basic loop with timeout
+
+```python
+from FlexibleLoop import FlexibleWhile
+
+loop = FlexibleWhile(timeout=5.0)
+
+for _ in loop:
+    # Runs until 5 seconds have elapsed
+    do_something()
+```
+
+### Loop with a condition function
+
+```python
+def condition(value):
+    return value < 100
+
+def update(value):
+    return value + 7
+
+loop = FlexibleWhile(
+    before_func=update,
+    cond_func=condition,
+    start_vals=(0,)
+)
+
+for value in loop:
+    print(value)
+# Prints: 7, 14, 21, ... up to 98
+```
+
+### Loop with max iterations and a callback
+
+```python
+def on_limit():
+    print("Max iterations reached")
+
+loop = FlexibleWhile(
+    max_iterations=10,
+    on_max_iterations=on_limit
+)
+
+for _ in loop:
+    do_something()
+```
+
+### Accessing loop metadata
+
+```python
+loop = FlexibleWhile(timeout=3.0)
+for _ in loop:
+    pass
+
+print(f"Completed {loop.iterations} iterations in {loop.time_elapsed:.2f}s")
+```
+
+---
+
+## API Reference
+
+### `FlexibleWhile(before_func, cond_func, start_vals, timeout, max_iterations, on_timeout, on_max_iterations)`
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `before_func` | callable | None | Called before each iteration. Return value updates loop variable(s). |
+| `cond_func` | callable | None | Loop continues while this returns `True`. `None` is equivalent to `while True`. |
+| `start_vals` | tuple | `(None,)` | Initial values passed to `before_func` and `cond_func` on first iteration. |
+| `timeout` | float | None | Maximum loop duration in seconds. |
+| `max_iterations` | int | None | Maximum number of iterations. |
+| `on_timeout` | callable | None | Called when timeout is reached. |
+| `on_max_iterations` | callable | None | Called when max iterations is reached. |
+
+### Instance attributes (after iteration)
+
+| Attribute | Description |
+|---|---|
+| `loop.iterations` | Number of completed iterations |
+| `loop.time_elapsed` | Total elapsed time in seconds |
+| `loop.values` | Current value(s) of the loop variable |
+
+---
+
+## License
+
+MIT License — free to use, modify, and distribute, including commercially.  
+Attribution required: please credit **Dr. Tolga Kaan Kanatlı** in any derivative work or product.
+
+---
+
+## Author
+
+**Dr. Tolga Kaan Kanatlı**  
+PhD in Chemical Engineering — PEM Fuel Cells & Hydrogen Production  
+[GitHub](https://github.com/tolgakanatli) · [LinkedIn](https://www.linkedin.com/in/tolgakanatli) · tolgakanatli@hotmail.com

flexibleloop-0.1.0/flexibleloop/FlexibleLoop.py

@@ -0,0 +1,133 @@
+import time
+import inspect
+
+class FlexibleWhile:
+    """
+    A flexible, customizable loop class that provides more control over loop behavior than the standard Python `while` loop.
+
+    Attributes:
+        before_func (callable, optional): A function to be executed before each iteration of the loop. This function can modify variables or perform actions that affect the loop's behavior. Defaults to None.
+        cond_func (callable, optional): A function that determines the loop's condition. If this function returns True, the loop continues; if it returns False, the loop stops. Defaults to None.
+        start_vals (tuple, optional): A tuple containing the initial values for variables used within the loop. Defaults to (None,).
+        timeout (float, optional): A maximum time limit for the loop. If the loop runs for longer than this time, it will stop. Defaults to None.
+        max_iterations (int, optional): A maximum number of iterations for the loop. If the loop runs for more iterations than this, it will stop. Defaults to None.
+        on_timeout (callable, optional): A function to be called if the loop times out. Defaults to None.
+        on_max_iterations (callable, optional): A function to be called if the loop reaches the maximum number of iterations. Defaults to None.
+        values (tuple): A tuple that holds the current values of the loop's variables.
+        start_time (float): Stores the time when the loop starts.
+        iterations (int): Keeps track of the number of iterations the loop has completed.
+    """
+    def __init__(self, 
+                 before_func=None, 
+                 cond_func=None,
+                 start_vals: tuple=(None,),
+                 timeout=None, max_iterations=None,
+                 on_timeout=None, 
+                 on_max_iterations=None):
+        
+        """
+        Initializes a FlexibleWhile object.
+
+        Args:
+            before_func (callable, optional): Function to execute before each iteration.
+            cond_func (callable, optional): Function to determine loop condition. Setting to None is equivalent to "while True:". Defaults to None.
+            start_vals (tuple, optional): Initial values for loop variables. Defaults to (None,). If your before_func uses values from previous loop, you must set these.
+            timeout (float, optional): Maximum loop time in seconds.
+            max_iterations (int, optional): Maximum loop iterations.
+            on_timeout (callable, optional): Function to call on timeout.
+            on_max_iterations (callable, optional): Function to call on max iterations.
+        """
+        
+        self.before_func = before_func
+        self.cond_func = cond_func
+        self.timeout = timeout
+        self.max_iterations = max_iterations
+        self.on_timeout = on_timeout
+        self.on_max_iterations = on_max_iterations
+        self.values = start_vals
+        self.start_time = None
+        self.iterations = 0
+
+    def __iter__(self):
+        """
+        Makes the FlexibleWhile object iterable, allowing it to be used in a for loop.
+
+        Returns:
+            self: The FlexibleWhile object itself.
+        """
+        self.start_time = time.time()
+        self.iterations = 0
+        return self
+
+    def __next__(self):
+        """
+        Executes the next iteration of the loop.
+
+        Returns:
+            tuple: The current values of the loop's variables.
+
+        Raises:
+            StopIteration: If the loop condition is not met, the timeout is reached, or the maximum number of iterations is reached.
+        """
+        self.time_elapsed = time.time() - self.start_time
+        if self.timeout and self.time_elapsed > self.timeout:
+            if self.on_timeout:
+                self._call_func(self.on_timeout)
+            raise StopIteration("Timeout reached")
+
+        if self.max_iterations and self.iterations >= self.max_iterations:
+            if self.on_max_iterations:
+                self._call_func(self.on_max_iterations)
+            raise StopIteration("Max iterations reached")
+
+        # Update values before checking the condition
+        result = self._call_func(self.before_func)
+        if result is not None:
+            # Ensure values is a tuple
+            if not isinstance(result, tuple):
+                self.values = (result,)
+            else:
+                self.values = result
+
+        # Check the condition function
+        if self.cond_func and not self._call_func(self.cond_func):
+            raise StopIteration("Condition not met")
+
+        self.iterations += 1
+
+        # Return values ensuring it's not a tuple if there's only one item
+        if len(self.values) == 1:
+            return self.values[0]
+        else:
+            return self.values
+
+    def _call_func(self, func):
+        """
+        Calls a function with the appropriate arguments.
+
+        Args:
+            func (callable): The function to call.
+
+        Returns:
+            Any: The result of the function call.
+        """
+        if func is None:
+            return
+        if callable(func):
+            # Use inspect to get function signature
+            sig = inspect.signature(func)
+            params = sig.parameters
+            num_params = len(params)
+            
+            if num_params == 0:
+                return func()
+            elif num_params == 1:
+                result = func(self.values[0])
+                return result
+            else:
+                return func(*self.values)
+        return
+
+
+if __name__ == "__main__":
+    print("Module loaded")

flexibleloop-0.1.0/flexibleloop/__init__.py

@@ -0,0 +1 @@
+#no one but ghosts here

flexibleloop-0.1.0/flexibleloop.egg-info/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: flexibleloop
+Version: 0.1.0
+Summary: A flexible, customizable while loop for Python with timeout, iteration limits, and pre-iteration hooks.
+Author-email: "Dr. Tolga Kaan Kanatlı" <tolgakanatli@hotmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 tolgakanatli
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/tolgakanatli/flexibleloop
+Keywords: loop,while,timeout,iteration,utility
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# flexibleloop
+
+A Python utility that extends the standard `while` loop with built-in timeout control, iteration limits, pre-iteration hooks, and dynamic condition functions — all through a clean `for`-loop interface.
+
+---
+
+## Why
+
+Python's `while` loop is simple but limited. Adding a timeout, counting iterations, or updating variables before checking a condition requires boilerplate every time. `FlexibleWhile` packages all of that into a reusable, configurable object.
+
+---
+
+## Features
+
+- **Timeout** — Stop the loop automatically after a set number of seconds
+- **Max iterations** — Cap the number of iterations without a counter variable
+- **Before function** — Run a function before each iteration; its return value becomes the loop variable
+- **Condition function** — Define the loop condition as a callable instead of inline logic
+- **Callbacks** — Execute custom functions when timeout or max iterations are hit
+- **Clean interface** — Used as a standard `for` loop; no new syntax to learn
+
+---
+
+## Installation
+
+Clone the repository and import directly:
+
+```bash
+git clone https://github.com/tolgakanatli/flexiblewhile.git
+```
+
+```python
+from FlexibleLoop import FlexibleWhile
+```
+
+---
+
+## Usage
+
+### Basic loop with timeout
+
+```python
+from FlexibleLoop import FlexibleWhile
+
+loop = FlexibleWhile(timeout=5.0)
+
+for _ in loop:
+    # Runs until 5 seconds have elapsed
+    do_something()
+```
+
+### Loop with a condition function
+
+```python
+def condition(value):
+    return value < 100
+
+def update(value):
+    return value + 7
+
+loop = FlexibleWhile(
+    before_func=update,
+    cond_func=condition,
+    start_vals=(0,)
+)
+
+for value in loop:
+    print(value)
+# Prints: 7, 14, 21, ... up to 98
+```
+
+### Loop with max iterations and a callback
+
+```python
+def on_limit():
+    print("Max iterations reached")
+
+loop = FlexibleWhile(
+    max_iterations=10,
+    on_max_iterations=on_limit
+)
+
+for _ in loop:
+    do_something()
+```
+
+### Accessing loop metadata
+
+```python
+loop = FlexibleWhile(timeout=3.0)
+for _ in loop:
+    pass
+
+print(f"Completed {loop.iterations} iterations in {loop.time_elapsed:.2f}s")
+```
+
+---
+
+## API Reference
+
+### `FlexibleWhile(before_func, cond_func, start_vals, timeout, max_iterations, on_timeout, on_max_iterations)`
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `before_func` | callable | None | Called before each iteration. Return value updates loop variable(s). |
+| `cond_func` | callable | None | Loop continues while this returns `True`. `None` is equivalent to `while True`. |
+| `start_vals` | tuple | `(None,)` | Initial values passed to `before_func` and `cond_func` on first iteration. |
+| `timeout` | float | None | Maximum loop duration in seconds. |
+| `max_iterations` | int | None | Maximum number of iterations. |
+| `on_timeout` | callable | None | Called when timeout is reached. |
+| `on_max_iterations` | callable | None | Called when max iterations is reached. |
+
+### Instance attributes (after iteration)
+
+| Attribute | Description |
+|---|---|
+| `loop.iterations` | Number of completed iterations |
+| `loop.time_elapsed` | Total elapsed time in seconds |
+| `loop.values` | Current value(s) of the loop variable |
+
+---
+
+## License
+
+MIT License — free to use, modify, and distribute, including commercially.  
+Attribution required: please credit **Dr. Tolga Kaan Kanatlı** in any derivative work or product.
+
+---
+
+## Author
+
+**Dr. Tolga Kaan Kanatlı**  
+PhD in Chemical Engineering — PEM Fuel Cells & Hydrogen Production  
+[GitHub](https://github.com/tolgakanatli) · [LinkedIn](https://www.linkedin.com/in/tolgakanatli) · tolgakanatli@hotmail.com

flexibleloop-0.1.0/flexibleloop.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+flexibleloop/FlexibleLoop.py
+flexibleloop/__init__.py
+flexibleloop.egg-info/PKG-INFO
+flexibleloop.egg-info/SOURCES.txt
+flexibleloop.egg-info/dependency_links.txt
+flexibleloop.egg-info/top_level.txt
+tests/test.py

flexibleloop-0.1.0/flexibleloop.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flexibleloop-0.1.0/flexibleloop.egg-info/top_level.txt

@@ -0,0 +1 @@
+flexibleloop

flexibleloop-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "flexibleloop"
+version = "0.1.0"
+description = "A flexible, customizable while loop for Python with timeout, iteration limits, and pre-iteration hooks."
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+    { name = "Dr. Tolga Kaan Kanatlı", email = "tolgakanatli@hotmail.com" }
+]
+keywords = ["loop", "while", "timeout", "iteration", "utility"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.8"
+
+[project.urls]
+Homepage = "https://github.com/tolgakanatli/flexibleloop"

flexibleloop-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

flexibleloop-0.1.0/tests/test.py

@@ -0,0 +1,76 @@
+#test code for flexible while
+from flexibleloop.FlexibleLoop import FlexibleWhile
+import time
+
+######## EXAMPLE 1: GENERAL USAGE ########
+a = 0
+b = 10
+
+def before(): #define a function to be run before each condition check
+    global a, b #you can use global a and b like this, or use the start_vals argument for a closed loop.
+    a += 1
+    b -= 1
+    return a, b
+
+def condition(a, b): #define the condition of the while loop, using the variables processed before
+    return a < 5 and b > 5
+
+print("Test 1")
+# Using the FlexibleWhile as an iterator
+for a,b in FlexibleWhile(before_func=before, cond_func=condition):
+    print(f"Current values: a={a}, b={b}")
+    if a == 3:
+        print("Good value, continuing...")
+        continue
+    if b == 8:
+        print("Eh, close enough")
+        break
+      
+print("Test 1 ended")
+
+
+######## EXAMPLE 2: LAMBDA USE ########
+
+print("\n Test 2")
+starttime = time.time()    
+for timer in FlexibleWhile(before_func=     lambda: time.time()-starttime, #you can use lambda to make it easier
+                           cond_func=       lambda timer: timer < 5, #gets the timer value from the before_funcs output
+                           max_iterations=  10, #the loop will break after 10 iterations max
+                           on_max_iterations=lambda: print("Max iterations reached")): #function to call if max_iterations is reached
+    print(timer)
+    time.sleep(1)
+
+print("Loop 2 ended")
+
+
+######### EXAMPLE 3: TIMEOUT ##########
+
+print("\n Test 3")
+for a,b in FlexibleWhile(before_func=   lambda a,b: (a+1,b+2), #example function
+                         cond_func=     None, #this (or omitting cond_func alltogether) is the same as "while true:"
+                         start_vals =   (0,0), #Starting vars of a and b. Must be a tuple even if you have a single var.
+                         timeout=       1,
+                         on_timeout=    lambda: print("Timeout reached")): #timeout in seconds. will break out if reached.
+    print(a,b)
+    time.sleep(0.1) 
+
+print("Loop 3 ended")
+
+######### EXAMPLE 3: CHANGING VARS WITHIN LOOP ##########
+print("\n Test 4")
+
+#you can get the class
+MyLoop = FlexibleWhile(before_func  = lambda v: v*v, #square the v
+                       cond_func    = lambda v: v!=-999, #an impossible condition
+                       start_vals   = (2,), #must be a tuple, even for a single value
+                       timeout      = 2,
+                       on_timeout   = lambda v: print(f"\nTimeout of {MyLoop.timeout} seconds reached with a value of {v} in {MyLoop.iterations} iterations"))
+                   
+for v in MyLoop:
+    print(f"{v} at {MyLoop.time_elapsed:.2f}")
+    if v > 256:
+        print(f"slow down buckaroo {v} is too high")
+        MyLoop.values = (2,) #"v=2" will not set the internal value. You must use this. Remember to use tuples.
+    time.sleep(0.1)
+    
+print(f"Loop 4 ended with {v}")