@tushar-br/desktop 1.0.283 → 1.0.284

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/tqdm/contrib/utils_worker.py

@@ -1,38 +0,0 @@
-"""
-IO/concurrency helpers for `tqdm.contrib`.
-"""
-from collections import deque
-from concurrent.futures import ThreadPoolExecutor
-
-from ..auto import tqdm as tqdm_auto
-
-__author__ = {"github.com/": ["casperdcl"]}
-__all__ = ['MonoWorker']
-
-
-class MonoWorker:
-    """
-    Supports one running task and one waiting task.
-    The waiting task is the most recent submitted (others are discarded).
-    """
-    def __init__(self):
-        self.pool = ThreadPoolExecutor(max_workers=1)
-        self.futures = deque([], 2)
-
-    def submit(self, func, *args, **kwargs):
-        """`func(*args, **kwargs)` may replace currently waiting task."""
-        futures = self.futures
-        if len(futures) == futures.maxlen:
-            running = futures.popleft()
-            if not running.done():
-                if len(futures):  # clear waiting
-                    waiting = futures.pop()
-                    waiting.cancel()
-                futures.appendleft(running)  # re-insert running
-        try:
-            waiting = self.pool.submit(func, *args, **kwargs)
-        except Exception as e:
-            tqdm_auto.write(str(e))
-        else:
-            futures.append(waiting)
-            return waiting

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/tqdm/dask.py

@@ -1,44 +0,0 @@
-from functools import partial
-
-from dask.callbacks import Callback
-
-from .auto import tqdm as tqdm_auto
-
-__author__ = {"github.com/": ["casperdcl"]}
-__all__ = ['TqdmCallback']
-
-
-class TqdmCallback(Callback):
-    """Dask callback for task progress."""
-    def __init__(self, start=None, pretask=None, tqdm_class=tqdm_auto,
-                 **tqdm_kwargs):
-        """
-        Parameters
-        ----------
-        tqdm_class  : optional
-            `tqdm` class to use for bars [default: `tqdm.auto.tqdm`].
-        tqdm_kwargs  : optional
-            Any other arguments used for all bars.
-        """
-        super().__init__(start=start, pretask=pretask)
-        if tqdm_kwargs:
-            tqdm_class = partial(tqdm_class, **tqdm_kwargs)
-        self.tqdm_class = tqdm_class
-
-    def _start_state(self, _, state):
-        self.pbar = self.tqdm_class(total=sum(
-            len(state[k]) for k in ['ready', 'waiting', 'running', 'finished']))
-
-    def _posttask(self, *_, **__):
-        self.pbar.update()
-
-    def _finish(self, *_, **__):
-        self.pbar.close()
-
-    def display(self):
-        """Displays in the current cell in Notebooks."""
-        container = getattr(self.bar, 'container', None)
-        if container is None:
-            return
-        from .notebook import display
-        display(container)

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/tqdm/gui.py

@@ -1,179 +0,0 @@
-"""
-Matplotlib GUI progressbar decorator for iterators.
-
-Usage:
->>> from tqdm.gui import trange, tqdm
->>> for i in trange(10):
-...     ...
-"""
-# future division is important to divide integers and get as
-# a result precise floating numbers (instead of truncated int)
-import re
-from warnings import warn
-
-# to inherit from the tqdm class
-from .std import TqdmExperimentalWarning
-from .std import tqdm as std_tqdm
-
-# import compatibility functions and utilities
-
-__author__ = {"github.com/": ["casperdcl", "lrq3000"]}
-__all__ = ['tqdm_gui', 'tgrange', 'tqdm', 'trange']
-
-
-class tqdm_gui(std_tqdm):  # pragma: no cover
-    """Experimental Matplotlib GUI version of tqdm!"""
-    # TODO: @classmethod: write() on GUI?
-    def __init__(self, *args, **kwargs):
-        from collections import deque
-
-        import matplotlib as mpl
-        import matplotlib.pyplot as plt
-        kwargs = kwargs.copy()
-        kwargs['gui'] = True
-        colour = kwargs.pop('colour', 'g')
-        super().__init__(*args, **kwargs)
-
-        if self.disable:
-            return
-
-        warn("GUI is experimental/alpha", TqdmExperimentalWarning, stacklevel=2)
-        self.mpl = mpl
-        self.plt = plt
-
-        # Remember if external environment uses toolbars
-        self.toolbar = self.mpl.rcParams['toolbar']
-        self.mpl.rcParams['toolbar'] = 'None'
-
-        self.mininterval = max(self.mininterval, 0.5)
-        self.fig, ax = plt.subplots(figsize=(9, 2.2))
-        # self.fig.subplots_adjust(bottom=0.2)
-        total = self.__len__()  # avoids TypeError on None #971
-        if total is not None:
-            self.xdata = []
-            self.ydata = []
-            self.zdata = []
-        else:
-            self.xdata = deque([])
-            self.ydata = deque([])
-            self.zdata = deque([])
-        self.line1, = ax.plot(self.xdata, self.ydata, color='b')
-        self.line2, = ax.plot(self.xdata, self.zdata, color='k')
-        ax.set_ylim(0, 0.001)
-        if total is not None:
-            ax.set_xlim(0, 100)
-            ax.set_xlabel("percent")
-            self.fig.legend((self.line1, self.line2), ("cur", "est"),
-                            loc='center right')
-            # progressbar
-            self.hspan = plt.axhspan(0, 0.001, xmin=0, xmax=0, color=colour)
-        else:
-            # ax.set_xlim(-60, 0)
-            ax.set_xlim(0, 60)
-            ax.invert_xaxis()
-            ax.set_xlabel("seconds")
-            ax.legend(("cur", "est"), loc='lower left')
-        ax.grid()
-        # ax.set_xlabel('seconds')
-        ax.set_ylabel((self.unit if self.unit else "it") + "/s")
-        if self.unit_scale:
-            plt.ticklabel_format(style='sci', axis='y', scilimits=(0, 0))
-            ax.yaxis.get_offset_text().set_x(-0.15)
-
-        # Remember if external environment is interactive
-        self.wasion = plt.isinteractive()
-        plt.ion()
-        self.ax = ax
-
-    def close(self):
-        if self.disable:
-            return
-
-        self.disable = True
-
-        with self.get_lock():
-            self._instances.remove(self)
-
-        # Restore toolbars
-        self.mpl.rcParams['toolbar'] = self.toolbar
-        # Return to non-interactive mode
-        if not self.wasion:
-            self.plt.ioff()
-        if self.leave:
-            self.display()
-        else:
-            self.plt.close(self.fig)
-
-    def clear(self, *_, **__):
-        pass
-
-    def display(self, *_, **__):
-        n = self.n
-        cur_t = self._time()
-        elapsed = cur_t - self.start_t
-        delta_it = n - self.last_print_n
-        delta_t = cur_t - self.last_print_t
-
-        # Inline due to multiple calls
-        total = self.total
-        xdata = self.xdata
-        ydata = self.ydata
-        zdata = self.zdata
-        ax = self.ax
-        line1 = self.line1
-        line2 = self.line2
-        hspan = getattr(self, 'hspan', None)
-        # instantaneous rate
-        y = delta_it / delta_t
-        # overall rate
-        z = n / elapsed
-        # update line data
-        xdata.append(n * 100.0 / total if total else cur_t)
-        ydata.append(y)
-        zdata.append(z)
-
-        # Discard old values
-        # xmin, xmax = ax.get_xlim()
-        # if (not total) and elapsed > xmin * 1.1:
-        if (not total) and elapsed > 66:
-            xdata.popleft()
-            ydata.popleft()
-            zdata.popleft()
-
-        ymin, ymax = ax.get_ylim()
-        if y > ymax or z > ymax:
-            ymax = 1.1 * y
-            ax.set_ylim(ymin, ymax)
-            ax.figure.canvas.draw()
-
-        if total:
-            line1.set_data(xdata, ydata)
-            line2.set_data(xdata, zdata)
-            if hspan:
-                hspan.set_xy((0, ymin))
-                hspan.set_height(ymax - ymin)
-                hspan.set_width(n / total)
-        else:
-            t_ago = [cur_t - i for i in xdata]
-            line1.set_data(t_ago, ydata)
-            line2.set_data(t_ago, zdata)
-
-        d = self.format_dict
-        # remove {bar}
-        d['bar_format'] = (d['bar_format'] or "{l_bar}<bar/>{r_bar}").replace(
-            "{bar}", "<bar/>")
-        msg = self.format_meter(**d)
-        if '<bar/>' in msg:
-            msg = "".join(re.split(r'\|?<bar/>\|?', msg, maxsplit=1))
-        ax.set_title(msg, fontname="DejaVu Sans Mono", fontsize=11)
-        self.plt.pause(1e-9)
-
-
-def tgrange(*args, **kwargs):
-    """Shortcut for `tqdm.gui.tqdm(range(*args), **kwargs)`."""
-    return tqdm_gui(range(*args), **kwargs)
-
-
-# Aliases
-tqdm = tqdm_gui
-trange = tgrange

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/tqdm/keras.py

@@ -1,122 +0,0 @@
-from copy import copy
-from functools import partial
-
-from .auto import tqdm as tqdm_auto
-
-try:
-    import keras
-except (ImportError, AttributeError) as e:
-    try:
-        from tensorflow import keras
-    except ImportError:
-        raise e
-__author__ = {"github.com/": ["casperdcl"]}
-__all__ = ['TqdmCallback']
-
-
-class TqdmCallback(keras.callbacks.Callback):
-    """Keras callback for epoch and batch progress."""
-    @staticmethod
-    def bar2callback(bar, pop=None, delta=(lambda logs: 1)):
-        def callback(_, logs=None):
-            n = delta(logs)
-            if logs:
-                if pop:
-                    logs = copy(logs)
-                    [logs.pop(i, 0) for i in pop]
-                bar.set_postfix(logs, refresh=False)
-            bar.update(n)
-
-        return callback
-
-    def __init__(self, epochs=None, data_size=None, batch_size=None, verbose=1,
-                 tqdm_class=tqdm_auto, **tqdm_kwargs):
-        """
-        Parameters
-        ----------
-        epochs  : int, optional
-        data_size  : int, optional
-            Number of training pairs.
-        batch_size  : int, optional
-            Number of training pairs per batch.
-        verbose  : int
-            0: epoch, 1: batch (transient), 2: batch. [default: 1].
-            Will be set to `0` unless both `data_size` and `batch_size`
-            are given.
-        tqdm_class  : optional
-            `tqdm` class to use for bars [default: `tqdm.auto.tqdm`].
-        tqdm_kwargs  : optional
-            Any other arguments used for all bars.
-        """
-        if tqdm_kwargs:
-            tqdm_class = partial(tqdm_class, **tqdm_kwargs)
-        self.tqdm_class = tqdm_class
-        self.epoch_bar = tqdm_class(total=epochs, unit='epoch')
-        self.on_epoch_end = self.bar2callback(self.epoch_bar)
-        if data_size and batch_size:
-            self.batches = batches = (data_size + batch_size - 1) // batch_size
-        else:
-            self.batches = batches = None
-        self.verbose = verbose
-        if verbose == 1:
-            self.batch_bar = tqdm_class(total=batches, unit='batch', leave=False)
-            self.on_batch_end = self.bar2callback(
-                self.batch_bar, pop=['batch', 'size'],
-                delta=lambda logs: logs.get('size', 1))
-
-    def on_train_begin(self, *_, **__):
-        params = self.params.get
-        auto_total = params('epochs', params('nb_epoch', None))
-        if auto_total is not None and auto_total != self.epoch_bar.total:
-            self.epoch_bar.reset(total=auto_total)
-
-    def on_epoch_begin(self, epoch, *_, **__):
-        if self.epoch_bar.n < epoch:
-            ebar = self.epoch_bar
-            ebar.n = ebar.last_print_n = ebar.initial = epoch
-        if self.verbose:
-            params = self.params.get
-            total = params('samples', params(
-                'nb_sample', params('steps', None))) or self.batches
-            if self.verbose == 2:
-                if hasattr(self, 'batch_bar'):
-                    self.batch_bar.close()
-                self.batch_bar = self.tqdm_class(
-                    total=total, unit='batch', leave=True,
-                    unit_scale=1 / (params('batch_size', 1) or 1))
-                self.on_batch_end = self.bar2callback(
-                    self.batch_bar, pop=['batch', 'size'],
-                    delta=lambda logs: logs.get('size', 1))
-            elif self.verbose == 1:
-                self.batch_bar.unit_scale = 1 / (params('batch_size', 1) or 1)
-                self.batch_bar.reset(total=total)
-            else:
-                raise KeyError('Unknown verbosity')
-
-    def on_train_end(self, *_, **__):
-        if hasattr(self, 'batch_bar'):
-            self.batch_bar.close()
-        self.epoch_bar.close()
-
-    def display(self):
-        """Displays in the current cell in Notebooks."""
-        container = getattr(self.epoch_bar, 'container', None)
-        if container is None:
-            return
-        from .notebook import display
-        display(container)
-        batch_bar = getattr(self, 'batch_bar', None)
-        if batch_bar is not None:
-            display(batch_bar.container)
-
-    @staticmethod
-    def _implements_train_batch_hooks():
-        return True
-
-    @staticmethod
-    def _implements_test_batch_hooks():
-        return True
-
-    @staticmethod
-    def _implements_predict_batch_hooks():
-        return True

package/staging_area/micro projects/SD -Advanced Media Processing Toolkit Automated Downloader, Segmenter & Neural Dubber/.venv/Lib/site-packages/tqdm/notebook.py

@@ -1,315 +0,0 @@
-"""
-IPython/Jupyter Notebook progressbar decorator for iterators.
-Includes a default `range` iterator printing to `stderr`.
-
-Usage:
->>> from tqdm.notebook import trange, tqdm
->>> for i in trange(10):
-...     ...
-"""
-# import compatibility functions and utilities
-import re
-import sys
-from html import escape
-from weakref import proxy
-
-# to inherit from the tqdm class
-from .std import tqdm as std_tqdm
-
-if True:  # pragma: no cover
-    # import IPython/Jupyter base widget and display utilities
-    IPY = 0
-    try:  # IPython 4.x
-        import ipywidgets
-        IPY = 4
-    except ImportError:  # IPython 3.x / 2.x
-        IPY = 32
-        import warnings
-        with warnings.catch_warnings():
-            warnings.filterwarnings(
-                'ignore', message=".*The `IPython.html` package has been deprecated.*")
-            try:
-                import IPython.html.widgets as ipywidgets  # NOQA: F401
-            except ImportError:
-                pass
-
-    try:  # IPython 4.x / 3.x
-        if IPY == 32:
-            from IPython.html.widgets import HTML
-            from IPython.html.widgets import FloatProgress as IProgress
-            from IPython.html.widgets import HBox
-            IPY = 3
-        else:
-            from ipywidgets import HTML
-            from ipywidgets import FloatProgress as IProgress
-            from ipywidgets import HBox
-    except ImportError:
-        try:  # IPython 2.x
-            from IPython.html.widgets import HTML
-            from IPython.html.widgets import ContainerWidget as HBox
-            from IPython.html.widgets import FloatProgressWidget as IProgress
-            IPY = 2
-        except ImportError:
-            IPY = 0
-            IProgress = None
-            HBox = object
-
-    try:
-        from IPython.display import display  # , clear_output
-    except ImportError:
-        pass
-
-__author__ = {"github.com/": ["lrq3000", "casperdcl", "alexanderkuk"]}
-__all__ = ['tqdm_notebook', 'tnrange', 'tqdm', 'trange']
-WARN_NOIPYW = ("IProgress not found. Please update jupyter and ipywidgets."
-               " See https://ipywidgets.readthedocs.io/en/stable"
-               "/user_install.html")
-
-
-class TqdmHBox(HBox):
-    """`ipywidgets.HBox` with a pretty representation"""
-    def _json_(self, pretty=None):
-        pbar = getattr(self, 'pbar', None)
-        if pbar is None:
-            return {}
-        d = pbar.format_dict
-        if pretty is not None:
-            d["ascii"] = not pretty
-        return d
-
-    def __repr__(self, pretty=False):
-        pbar = getattr(self, 'pbar', None)
-        if pbar is None:
-            return super().__repr__()
-        return pbar.format_meter(**self._json_(pretty))
-
-    def _repr_pretty_(self, pp, *_, **__):
-        pp.text(self.__repr__(True))
-
-
-class tqdm_notebook(std_tqdm):
-    """
-    Experimental IPython/Jupyter Notebook widget using tqdm!
-    """
-    @staticmethod
-    def status_printer(_, total=None, desc=None, ncols=None):
-        """
-        Manage the printing of an IPython/Jupyter Notebook progress bar widget.
-        """
-        # Fallback to text bar if there's no total
-        # DEPRECATED: replaced with an 'info' style bar
-        # if not total:
-        #    return super(tqdm_notebook, tqdm_notebook).status_printer(file)
-
-        # fp = file
-
-        # Prepare IPython progress bar
-        if IProgress is None:  # #187 #451 #558 #872
-            raise ImportError(WARN_NOIPYW)
-        if total:
-            pbar = IProgress(min=0, max=total)
-        else:  # No total? Show info style bar with no progress tqdm status
-            pbar = IProgress(min=0, max=1)
-            pbar.value = 1
-            pbar.bar_style = 'info'
-            if ncols is None:
-                pbar.layout.width = "20px"
-
-        ltext = HTML()
-        rtext = HTML()
-        if desc:
-            ltext.value = desc
-        container = TqdmHBox(children=[ltext, pbar, rtext])
-        # Prepare layout
-        if ncols is not None:  # use default style of ipywidgets
-            # ncols could be 100, "100px", "100%"
-            ncols = str(ncols)  # ipywidgets only accepts string
-            try:
-                if int(ncols) > 0:  # isnumeric and positive
-                    ncols += 'px'
-            except ValueError:
-                pass
-            pbar.layout.flex = '2'
-            container.layout.width = ncols
-            container.layout.display = 'inline-flex'
-            container.layout.flex_flow = 'row wrap'
-
-        return container
-
-    def display(self, msg=None, pos=None,
-                # additional signals
-                close=False, bar_style=None, check_delay=True):
-        # Note: contrary to native tqdm, msg='' does NOT clear bar
-        # goal is to keep all infos if error happens so user knows
-        # at which iteration the loop failed.
-
-        # Clear previous output (really necessary?)
-        # clear_output(wait=1)
-
-        if not msg and not close:
-            d = self.format_dict
-            # remove {bar}
-            d['bar_format'] = (d['bar_format'] or "{l_bar}<bar/>{r_bar}").replace(
-                "{bar}", "<bar/>")
-            msg = self.format_meter(**d)
-
-        ltext, pbar, rtext = self.container.children
-        pbar.value = self.n
-
-        if msg:
-            msg = msg.replace(' ', '\u2007')  # fix html space padding
-            # html escape special characters (like '&')
-            if '<bar/>' in msg:
-                left, right = map(escape, re.split(r'\|?<bar/>\|?', msg, maxsplit=1))
-            else:
-                left, right = '', escape(msg)
-
-            # Update description
-            ltext.value = left
-            # never clear the bar (signal: msg='')
-            if right:
-                rtext.value = right
-
-        # Change bar style
-        if bar_style:
-            # Hack-ish way to avoid the danger bar_style being overridden by
-            # success because the bar gets closed after the error...
-            if pbar.bar_style != 'danger' or bar_style != 'success':
-                pbar.bar_style = bar_style
-
-        # Special signal to close the bar
-        if close and pbar.bar_style != 'danger':  # hide only if no error
-            try:
-                self.container.close()
-            except AttributeError:
-                self.container.visible = False
-            self.container.layout.visibility = 'hidden'  # IPYW>=8
-
-        if check_delay and self.delay > 0 and not self.displayed:
-            display(self.container)
-            self.displayed = True
-
-    @property
-    def colour(self):
-        if hasattr(self, 'container'):
-            return self.container.children[-2].style.bar_color
-
-    @colour.setter
-    def colour(self, bar_color):
-        if hasattr(self, 'container'):
-            self.container.children[-2].style.bar_color = bar_color
-
-    def __init__(self, *args, **kwargs):
-        """
-        Supports the usual `tqdm.tqdm` parameters as well as those listed below.
-
-        Parameters
-        ----------
-        display  : Whether to call `display(self.container)` immediately
-            [default: True].
-        """
-        kwargs = kwargs.copy()
-        # Setup default output
-        file_kwarg = kwargs.get('file', sys.stderr)
-        if file_kwarg is sys.stderr or file_kwarg is None:
-            kwargs['file'] = sys.stdout  # avoid the red block in IPython
-
-        # Initialize parent class + avoid printing by using gui=True
-        kwargs['gui'] = True
-        # convert disable = None to False
-        kwargs['disable'] = bool(kwargs.get('disable', False))
-        colour = kwargs.pop('colour', None)
-        display_here = kwargs.pop('display', True)
-        super().__init__(*args, **kwargs)
-        if self.disable or not kwargs['gui']:
-            self.disp = lambda *_, **__: None
-            return
-
-        # Get bar width
-        self.ncols = '100%' if self.dynamic_ncols else kwargs.get("ncols", None)
-
-        # Replace with IPython progress bar display (with correct total)
-        unit_scale = 1 if self.unit_scale is True else self.unit_scale or 1
-        total = self.total * unit_scale if self.total else self.total
-        self.container = self.status_printer(self.fp, total, self.desc, self.ncols)
-        self.container.pbar = proxy(self)
-        self.displayed = False
-        if display_here and self.delay <= 0:
-            display(self.container)
-            self.displayed = True
-        self.disp = self.display
-        self.colour = colour
-
-        # Print initial bar state
-        if not self.disable:
-            self.display(check_delay=False)
-
-    def __iter__(self):
-        try:
-            it = super().__iter__()
-            yield from it
-        # NB: except ... [ as ...] breaks IPython async KeyboardInterrupt
-        except:  # NOQA
-            self.disp(bar_style='danger')
-            raise
-        # NB: don't `finally: close()`
-        # since this could be a shared bar which the user will `reset()`
-
-    def update(self, n=1):
-        try:
-            return super().update(n=n)
-        # NB: except ... [ as ...] breaks IPython async KeyboardInterrupt
-        except:  # NOQA
-            # cannot catch KeyboardInterrupt when using manual tqdm
-            # as the interrupt will most likely happen on another statement
-            self.disp(bar_style='danger')
-            raise
-        # NB: don't `finally: close()`
-        # since this could be a shared bar which the user will `reset()`
-
-    def close(self):
-        if self.disable:
-            return
-        super().close()
-        # Try to detect if there was an error or KeyboardInterrupt
-        # in manual mode: if n < total, things probably got wrong
-        if self.total and self.n < self.total:
-            self.disp(bar_style='danger', check_delay=False)
-        else:
-            if self.leave:
-                self.disp(bar_style='success', check_delay=False)
-            else:
-                self.disp(close=True, check_delay=False)
-
-    def clear(self, *_, **__):
-        pass
-
-    def reset(self, total=None):
-        """
-        Resets to 0 iterations for repeated use.
-
-        Consider combining with `leave=True`.
-
-        Parameters
-        ----------
-        total  : int or float, optional. Total to use for the new bar.
-        """
-        if self.disable:
-            return super().reset(total=total)
-        _, pbar, _ = self.container.children
-        pbar.bar_style = ''
-        if total is not None:
-            pbar.max = total
-            if not self.total and self.ncols is None:  # no longer unknown total
-                pbar.layout.width = None  # reset width
-        return super().reset(total=total)
-
-
-def tnrange(*args, **kwargs):
-    """Shortcut for `tqdm.notebook.tqdm(range(*args), **kwargs)`."""
-    return tqdm_notebook(range(*args), **kwargs)
-
-
-# Aliases
-tqdm = tqdm_notebook
-trange = tnrange