Confusion related to what is awaitable and what is not

I have just started using asyncio, and it is a bit confusing where could the await keyword be used, plus could it be applicable at more places, where it is currently invalid.
for example,
awaitable import

await import math

awaitable inheritance

class B:
    pass
class A(await B):
    pass

could I use await in front of builtins, like awaitable map, print, …

await map(...)
await print(...)
await list(...)

awaitable try catch,

await try:
    ...
await except:
    ...

awaitable decorator,

@(await decorator_name)
def func():
    ...

using await with if-else, match-case,

await if ...:
   ...
await else:
   ...

await match x:
    await case y: ...

could these be valid syntax in the future? (assume all of these are wrapped in an async function)

If you get a syntax error, like await import math and class A(await B), then you cannot use await there. There’s no trick to making it work.

But I cannot imagine what these things would actually do, if they were allowed. Can you explain what you expect “awaitable inheritance” actually to do?

from what I understand as of now,

a)

import asyncio, time
async def func_one():
    print(f'entered func_one {time.time()}')
    # 1) there would be a switch to func_two with the below await
    # 2) asyncio.sleep is awaitable, so it could be performed while the 
    #    for loop execution is going on in the second function
    await asyncio.sleep(1)
    # 5) the above sleep would have already finished 
    #    before we switch to this function
    print(f'exiting func_one {time.time()}')

async def func_two():
    print(f'entered func_two {time.time()}')
    # 3) the below for loop is like blocking code
    #    even after sleep of one second is over for func_one
    #    we will be in func_two only, waiting for the for loop to finish 
    #    (assume for loop takes >1 second to finish)
    for i in range(100000000): 
        pass
    print(f'in func_two: for loop execution completed {time.time()}')
    await asyncio.sleep(1) # 4) now we will switch to func_one
    print(f'exiting function_two {time.time()}')

asyncio.run(asyncio.gather(func_one(), func_two()))

entered func_one 1664973689.2533345
entered func_two 1664973689.2544205
in func_two: for loop execution completed 1664973691.804659
exiting func_one 1664973691.80543 # (it is just after for loop execution 
                  # completion, as one second sleep had already finished)
exiting function_two 1664973692.8068318
[None, None]

the confusion here is what could be awaitable,

  1. asyncio.sleep
  2. downloading some information
  3. asyncio.Queue() → put(), get()

what else is awaitable, or in other words could be performed while
some other task is going on (other task → like for loop here) in another function (func_two here)

b)

async def func_three():
  class B:
    def xyz(self):
        pass

  class A(await B):
    pass

  a = A() # for inheritance, maybe it could mean that updating the 
          # class dictionary of class A with methods of class B
          # could be done while some other task is going on in 
          # another function (again like lets say a for loop)

async def func_two():
    print(f'entered func_two {time.time()}')
    for i in range(100000000): 
        pass
    print(f'in func_two: for loop execution completed {time.time()}')
    await asyncio.sleep(1)
    print(f'exiting func_two {time.time()}')

asyncio.run(asyncio.gather(func_three(), func_two()))

similarly for import, maybe it could mean that the module is being imported
while some other task is going on in another function