Simplify code, rename variables and add test for nested partials

Author: pablogsal

Lib/inspect.py

@@ -168,40 +168,36 @@ def isfunction(object):
         __kwdefaults__  dict of keyword only parameters with defaults"""
     return isinstance(object, types.FunctionType)
 
-def isgeneratorfunction(object):
+def isgeneratorfunction(obj):
     """Return true if the object is a user-defined generator function.
 
     Generator function objects provide the same attributes as functions.
     See help(isfunction) for a list of attributes."""
-    is_generator_function = bool((isfunction(object) or ismethod(object)) and
-                object.__code__.co_flags & CO_GENERATOR)
-    is_partial_generator = bool((isinstance(object, functools.partial) and
-                object.func.__code__.co_flags & CO_GENERATOR))
-    return is_generator_function or is_partial_generator
+    while isinstance(obj, functools.partial):
+            obj = obj.func
+    return bool((isfunction(obj) or ismethod(obj)) and
+                obj.__code__.co_flags & CO_GENERATOR)
 
-def iscoroutinefunction(object):
+def iscoroutinefunction(obj):
     """Return true if the object is a coroutine function.
 
     Coroutine functions are defined with "async def" syntax.
     """
-    is_coroutine_function = bool(((isfunction(object) or ismethod(object)) and
-                object.__code__.co_flags & CO_COROUTINE))
-    is_partial_coroutine = bool((isinstance(object, functools.partial) and
-                object.func.__code__.co_flags & CO_COROUTINE))
-    return is_coroutine_function or is_partial_coroutine
+    while isinstance(obj, functools.partial):
+        obj = obj.func
+    return bool(((isfunction(obj) or ismethod(obj)) and
+                obj.__code__.co_flags & CO_COROUTINE))
 
-def isasyncgenfunction(object):
+def isasyncgenfunction(obj):
     """Return true if the object is an asynchronous generator function.
 
     Asynchronous generator functions are defined with "async def"
     syntax and have "yield" expressions in their body.
     """
-    is_async_gen_function = bool((isfunction(object) or ismethod(object)) and
-                object.__code__.co_flags & CO_ASYNC_GENERATOR)
-    is_partial_async_gen = bool((isinstance(object, functools.partial) and
-                object.func.__code__.co_flags & CO_ASYNC_GENERATOR))
-    return is_async_gen_function or is_partial_async_gen
-
+    while isinstance(obj, functools.partial):
+            obj = obj.func
+    return bool((isfunction(obj) or ismethod(obj)) and
+                obj.__code__.co_flags & CO_ASYNC_GENERATOR)
 
 def isasyncgen(object):
     """Return true if the object is an asynchronous generator."""

Lib/test/test_inspect.py

@@ -2,6 +2,7 @@
 import collections
 import datetime
 import functools
+from functools import partial
 import importlib
 import inspect
 import io
@@ -174,35 +175,35 @@ def test_iscoroutine(self):
             inspect.iscoroutinefunction(gen_coroutine_function_example))
         self.assertFalse(
             inspect.iscoroutinefunction(
-                functools.partial(gen_coroutine_function_example)))
+                partial(partial(gen_coroutine_function_example))))
         self.assertFalse(inspect.iscoroutine(gen_coro))
 
         self.assertTrue(
             inspect.isgeneratorfunction(gen_coroutine_function_example))
         self.assertTrue(
             inspect.isgeneratorfunction(
-                functools.partial(gen_coroutine_function_example)))
+                partial(partial(gen_coroutine_function_example))))
         self.assertTrue(inspect.isgenerator(gen_coro))
 
         self.assertTrue(
             inspect.iscoroutinefunction(coroutine_function_example))
         self.assertTrue(
             inspect.iscoroutinefunction(
-                functools.partial(coroutine_function_example)))
+                partial(partial(coroutine_function_example))))
         self.assertTrue(inspect.iscoroutine(coro))
 
         self.assertFalse(
             inspect.isgeneratorfunction(coroutine_function_example))
         self.assertFalse(
             inspect.isgeneratorfunction(
-                functools.partial(coroutine_function_example)))
+                partial(partial(coroutine_function_example))))
         self.assertFalse(inspect.isgenerator(coro))
 
         self.assertTrue(
             inspect.isasyncgenfunction(async_generator_function_example))
         self.assertTrue(
             inspect.isasyncgenfunction(
-                functools.partial(async_generator_function_example)))
+                partial(partial(async_generator_function_example))))
         self.assertTrue(inspect.isasyncgen(async_gen_coro))
 
         coro.close(); gen_coro.close(); # silence warnings