Cancellable tasks no longer get task_id as an arg.

Author: peterhinch

PRIMITIVES.md

@@ -360,21 +360,20 @@ async def comms():  # Perform some communications task
         # with known initial state on next pass.
 ```
 
-A `Cancellable` task is declared with the `@cancellable` decorator. When
-scheduled it will receive an initial arg which is a `TaskId` instance followed
-by any user-defined args. The `TaskId` instance is normally ignored however it
-can be useful for debugging - task_id() produces a unique integer task ID.
+A `Cancellable` task is declared with the `@cancellable` decorator:
 
 ```python
 @cancellable
-async def print_nums(_, num):  # Discard task_id
+async def print_nums(num):
     while True:
         print(num)
         num += 1
         await sleep(1)  # asyn.sleep() allows fast response to exception
 ```
 
-`Cancellable` tasks may be awaited or placed on the event loop:
+Positional or keyword arguments for the task are passed to the `Cancellable`
+constructor as below. Note that the coro is passed not using function call
+syntax. `Cancellable` tasks may be awaited or placed on the event loop:
 
 ```python
 await Cancellable(print_nums, 5)  # single arg to print_nums.
@@ -436,7 +435,7 @@ exception to perform custom cleanup operations. This may be done as below:
 
 ```python
 @cancellable
-async def foo(task_id, arg):
+async def foo():
     while True:
         try:
             await sleep(1)  # Main body of task
@@ -450,8 +449,7 @@ cancelled.
 
 ```python
 @cancellable
-async def bar(task_id):
-    task_no = task_id()  # Retrieve task no. from TaskId instance
+async def bar():
     try:
         await sleep(1)  # Main body of task
     except StopTask:
@@ -469,19 +467,17 @@ name may outlive the task: a coro may end but the class enables its state to be
 checked. It is a subclass of `Cancellable` and its constructor disallows
 duplicate names: each instance of a coro must be assigned a unique name.
 
-A `NamedTask` coro is defined with the `@cancellable` decorator. When scheduled
-it will receive an initial arg which is a `TaskId` instance followed by any
-user-defined args. Normally the `task_id` is ignored as per `Cancellable`.
+A `NamedTask` coro is defined with the `@cancellable` decorator.
 
 ```python
 @cancellable
-async def foo(_, arg1, arg2):
+async def foo(arg1, arg2):
     await asyn.sleep(1)
     print('Task foo has ended.', arg1, arg2)
 ```
 
-The `NamedTask` constructor takes the name, the coro, plus any user args. The
-resultant instance can be scheduled in the usual ways:
+The `NamedTask` constructor takes the name, the coro, plus any user positional
+or keyword args. Th eresultant instance can be scheduled in the usual ways:
 
 ```python
 await NamedTask('my foo', foo, 1, 2)  # Pause until complete or killed
@@ -492,7 +488,7 @@ loop.create_task(NamedTask('my nums', foo, 10, 11)())  # Note () syntax.
 Cancellation is performed with:
 
 ```python
-await NamedTask.cancel('my foo')  # API change
+await NamedTask.cancel('my foo')
 ```
 
 When cancelling a task there is no need to check if the task is still running:
@@ -557,7 +553,7 @@ The coro should have the following form:
 
 ```python
 @cancellable
-async def foo(task_id):
+async def foo():
     try:
         await asyncio.sleep(1)  # User code here
     except StopTask:
@@ -573,7 +569,8 @@ is to simplify the code and to ensure accuracy of the `is_running` method. The
 latest API changes are:  
  * `Cancellable.stopped()` is no longer a public method.
  * `NamedTask.cancel()` is now asynchronous.
- * `NamedTask` coros now receive a `TaskId` instance as their 1st arg.
+ * `NamedTask` and `Cancellable` coros no longer receive a `TaskId` instance as
+ their 1st arg.
  * `@namedtask` still works but is now an alias for `@cancellable`.
 
 The drive to simplify code comes from the fact that `uasyncio` is itself under

asyn.py

@@ -328,10 +328,13 @@ def __await__(self):
 
 def cancellable(f):
     def new_gen(*args, **kwargs):
-        g = f(*args, **kwargs)
-        # Task ID is args[1] if a bound method (else args[0])
-        idx = 0 if isinstance(args[0], TaskId) else 1
-        task_id = args[idx]
+        if isinstance(args[0], TaskId):  # Not a bound method
+            task_id = args[0]
+            g = f(*args[1:], **kwargs)
+        else:  # Task ID is args[1] if a bound method
+            task_id = args[1]
+            args = (args[0],) + args[2:]
+            g = f(*args, **kwargs)
         try:
             res = await g
             return res

asyn_demos.py

@@ -42,14 +42,14 @@ def print_tests():
 
 # Cancellable task minimal example
 @asyn.cancellable
-async def print_nums(_, num):
+async def print_nums(num):
     while True:
         print(num)
         num += 1
         await asyn.sleep(1)
 
 @asyn.cancellable
-async def add_one(_, num):
+async def add_one(num):
     num += 1
     await asyn.sleep(1)
     return num
@@ -70,14 +70,14 @@ def cancel_test():
 # NamedTask minimal example
 
 @asyn.cancellable
-async def print_nums_named(_, num):
+async def print_nums_named(num):
     while True:
         print(num)
         num += 1
         await asyn.sleep(1)
 
 @asyn.cancellable
-async def add_one_named(_, num):
+async def add_one_named(num):
     num += 1
     await asyn.sleep(1)
     return num
@@ -114,13 +114,13 @@ async def start(self, loop):
         print('Done')
 
     @asyn.cancellable
-    async def foo(self, _, arg):
+    async def foo(self, arg):
         while True:
             await asyn.sleep(1)
             print('foo running, arg', arg)
 
     @asyn.cancellable
-    async def bar(self, _, arg):
+    async def bar(self, arg):
         while True:
             await asyn.sleep(1)
             print('bar running, arg', arg)

cantest.py

@@ -56,7 +56,7 @@ def printexp(exp, runtime=0):
 # cancel_test1()
 
 @asyn.cancellable
-async def foo(task_id, num):
+async def foo(num):
     try:
         await asyncio.sleep(4)
     except asyn.StopTask:
@@ -109,7 +109,7 @@ async def forever(n):
 
 # Intercepting the StopTask exception.
 @asyn.cancellable
-async def rats(task_id, n):
+async def rats(n):
     try:
         await forever(n)
     except asyn.StopTask:
@@ -147,7 +147,7 @@ def test2():
 
 # Intercepting the StopTask exception.
 @asyn.cancellable
-async def cant3(task_id):
+async def cant3():
     try:
         await asyncio.sleep(1)
         print('Task cant3 has ended.')
@@ -187,51 +187,48 @@ def test3():
 # task_id automatically
 
 @asyn.cancellable
-async def cant40(task_id):
-    task_no = task_id()
+async def cant40(num):
     while True:
         try:
             await asyn.sleep(1)
-            print('Task cant40 no. {} running.'.format(task_no))
+            print('Task cant40 no. {} running.'.format(num))
         except asyn.StopTask:
-            print('Task cant40 no. {} was cancelled'.format(task_no))
+            print('Task cant40 no. {} was cancelled'.format(num))
             return
 
 @asyn.cancellable
-async def cant41(task_id, arg=0):
-    task_no = task_id()
+async def cant41(num, arg=0):
     try:
         await asyn.sleep(1)
-        print('Task cant41 no. {} running, arg {}.'.format(task_no, arg))
+        print('Task cant41 no. {} running, arg {}.'.format(num, arg))
     except asyn.StopTask:
-        print('Task cant41 no. {} was cancelled.'.format(task_no))
+        print('Task cant41 no. {} was cancelled.'.format(num))
         return
     else:
-        print('Task cant41 no. {} ended.'.format(task_no))
+        print('Task cant41 no. {} ended.'.format(num))
 
-async def cant42(task_no):
+async def cant42(num):
     while True:
-        print('Task cant42 no. {} running'.format(task_no))
+        print('Task cant42 no. {} running'.format(num))
         await asyn.sleep(1.2)
 
 # Test await syntax and throwing exception to subtask
 @asyn.cancellable
-async def chained(task_id, x, y, *, red, blue):
+async def chained(num, x, y, *, red, blue):
     print('Args:', x, y, red, blue)  # Test args and kwargs
-    task_no = task_id()
     try:
-        await cant42(task_no)
+        await cant42(num)
     except asyn.StopTask:
-        print('Task chained no. {} was cancelled'.format(task_no))
+        print('Task chained no. {} was cancelled'.format(num))
 
 async def run_cancel_test4():
-    await asyn.Cancellable(cant41, 5)
+    await asyn.Cancellable(cant41, 0)
     loop = asyncio.get_event_loop()
-    loop.create_task(asyn.Cancellable(cant40)())  # 3 instances in default group 0
-    loop.create_task(asyn.Cancellable(cant40)())
-    loop.create_task(asyn.Cancellable(cant40)())
-    loop.create_task(asyn.Cancellable(chained, 1, 2, red=3, blue=4, group=1)())
-    loop.create_task(asyn.Cancellable(cant41)())  # Runs to completion
+    loop.create_task(asyn.Cancellable(cant40, 1)())  # 3 instances in default group 0
+    loop.create_task(asyn.Cancellable(cant40, 2)())
+    loop.create_task(asyn.Cancellable(cant40, 3)())
+    loop.create_task(asyn.Cancellable(chained, 4, 1, 2, red=3, blue=4, group=1)())
+    loop.create_task(asyn.Cancellable(cant41, 5)())  # Runs to completion
     print('Running tasks')
     await asyncio.sleep(3)
     print('About to cancel group 0 tasks')
@@ -288,7 +285,7 @@ async def start(self, loop):
         print('Done')
 
     @asyn.cancellable
-    async def foo(self, _, arg):
+    async def foo(self, arg):
         try:
             while True:
                 await asyn.sleep(1)
@@ -297,7 +294,7 @@ async def foo(self, _, arg):
             print('foo was cancelled')
 
     @asyn.cancellable
-    async def bar(self, _, arg, *, x=1, y=2):
+    async def bar(self, arg, *, x=1, y=2):
         try:
             while True:
                 await asyn.sleep(1)
@@ -334,20 +331,19 @@ def test5():
 
 # test 6: test NamedTask.is_running()
 @asyn.cancellable
-async def cant60(task_id, name):
-    task_no = task_id()
-    print('Task cant60 no. {} name \"{}\" running.'.format(task_no, name))
+async def cant60(name):
+    print('Task cant60 name \"{}\" running.'.format(name))
     try:
         for _ in range(5):
             await asyncio.sleep(2)  # 2 secs latency.
     except asyn.StopTask:
-        print('Task cant60 no. {} name \"{}\" was cancelled.'.format(task_no, name))
+        print('Task cant60 name \"{}\" was cancelled.'.format(name))
         return
     else:
-        print('Task cant60 no. {} name \"{}\" ended.'.format(task_no, name))
+        print('Task cant60 name \"{}\" ended.'.format(name))
 
 @asyn.cancellable
-async def cant61(task_id):
+async def cant61():
     try:
         while True:
             for name in ('complete', 'cancel me'):
@@ -378,8 +374,8 @@ async def run_cancel_test6(loop):
 
 
 def test6():
-    printexp('''Task cant60 no. 0 name "complete" running.
-Task cant60 no. 1 name "cancel me" running.
+    printexp('''Task cant60 name "complete" running.
+Task cant60 name "cancel me" running.
 Task "complete" running: True
 Task "cancel me" running: True
 Task "complete" running: True
@@ -393,7 +389,7 @@ def test6():
 Cancelling task "cancel me". 1.5 secs latency.
 Task "complete" running: True
 Task "cancel me" running: True
-Task cant60 no. 1 name "cancel me" was cancelled.
+Task cant60 name "cancel me" was cancelled.
 Task "complete" running: True
 Task "cancel me" running: False
 Task "complete" running: True
@@ -402,18 +398,18 @@ def test6():
 Task "cancel me" running: False
 Task "complete" running: True
 Task "cancel me" running: False
-Task cant60 no. 0 name "complete" ended.
+Task cant60 name "complete" ended.
 Task "complete" running: False
 Task "cancel me" running: False
 Task "complete" running: False
 Task "cancel me" running: False
-Task cant60 no. 3 name "cancel wait" running.
+Task cant60 name "cancel wait" running.
 Cancelling task "cancel wait". 1.5 secs latency.
 Task "complete" running: False
 Task "cancel me" running: False
 Task "complete" running: False
 Task "cancel me" running: False
-Task cant60 no. 3 name "cancel wait" was cancelled.
+Task cant60 name "cancel wait" was cancelled.
 Was cancelled in 1503 ms
 Cancelling cant61
 Task cant61 cancelled.