Codecov Report

Merging #1004 into devel will increase coverage by 0.25%.
The diff coverage is 95.23%.

@@            Coverage Diff             @@
##            devel    #1004      +/-   ##
==========================================
+ Coverage   87.16%   87.42%   +0.25%     
==========================================
  Files          21       22       +1     
  Lines        1278     1320      +42     
  Branches      217      223       +6     
==========================================
+ Hits         1114     1154      +40     
  Misses        143      143              
- Partials       21       23       +2     

I have one question about your design. If I understand your code correctly, tqdm_asyncio presents an asynchronous interface even for synchronous iterables. You went through some extra work to make that possible but is it desirable? I would be happy to use a different async progress class but it certainly is convenient to not have to care whether my iterable is async or sync.

it certainly is convenient to not have to care whether my iterable is async or sync

yes exactly. This PR aims to address multiple issues for ease of use.

Also as I understand async and coroutine are actually two different things - there are differently-implemented "coroutines" in python2, for example. Would this be of interest? Maybe just in documentation?

from tqdm.auto import tqdm as tqdm_auto


# based on http://www.dabeaz.com/coroutines/copipe.py
def autonext(func):
    def inner(*args, **kwargs):
        res = func(*args,**kwargs)
        res.next()
        return res
    return inner

class tqdm_coro(tqdm_auto):
    @classmethod
    @autonext
    def pipe(cls, target, **tkwargs):
        """
        Python2 coroutine-style pipe.

        This:
            r = receiver()
            p = producer(r)
            r.next()
            p.next()
        Becomes:
            r = receiver()
            t = tqdm.pipe(r)
            p = producer(t)
            r.next()
            p.next()
        """
        with cls(**tkwargs) as pbar:
            while True:
                obj = (yield)
                target.send(obj)
                pbar.update()

def source(target):
    for i in ["foo", "bar", "baz", "pythonista", "python", "py"]:
        target.send(i)

@autonext
def grep(pattern, target):
    while True:
        line = (yield)
        if pattern in line:
            target.send(line)

@autonext
def sink():
    while True:
         line = (yield)
         tqdm_coro.write(line)

source(
    tqdm_coro.pipe(
        grep('python',
            sink())))

Also as I understand async and coroutine are actually two different things - there are differently-implemented "coroutines" in python2, for example. Would this be of interest? Maybe just in documentation?

I don't have the bandwidth in my own projects so I started only supporting Python 3.6+. Looking at the classifiers on PyPI, you go as far back as supporting 2.6 which is pretty tough I think.

As far as I understood the topic so far, all asynchronous functions are coroutines. The syntax simply changed from the @asyncio.coroutine decorator to the (in my opinion) cleaner async keyword. It's possible that there are multiple implementations in Python 2 since asyncio only became widely useable in Python 3.5.

I'm talking about something which predates even @asyncio.coroutine.

In python2, the word coroutine referred to a type of generator obect driven by send() rather than next(), and had nothing to do with asynchronicity.

Thank you for making this happen @casperdcl 🙂

whew all done in tqdm>=4.48.0 https://tqdm.github.io/releases/#v4480-2020-07-16