def test_iscoroutinefunction_nested_partial():
async def my_async_callable(x, y, z):
pass
assert iscoroutinefunction(
functools.partial(functools.partial(my_async_callable, 1), 2)
)
def test_iscoroutinefunction_unhashable_input():
# Ensure iscoroutinefunction can handle unhashable callables
assert not iscoroutinefunction(_UnhashableCallable())
def __getattr__(self, key):
if self._future and self._future.status not in ("finished", "pending"):
raise ValueError("Worker holding Actor was lost. Status: " +
self._future.status)
if (self._worker and self._worker.address == self._address
and getattr(thread_state, "actor", False)):
# actor calls actor on same worker
actor = self._worker.actors[self.key]
attr = getattr(actor, key)
if iscoroutinefunction(attr):
return attr
elif callable(attr):
return lambda *args, **kwargs: EagerActorFuture(
attr(*args, **kwargs))
else:
return attr
attr = getattr(self._cls, key)
if callable(attr):
@functools.wraps(attr)
def func(*args, **kwargs):
async def run_actor_function_on_worker():
try:
result = await self._worker_rpc.actor_execute(
function=key,
actor=self.key,
args=[to_serialize(arg) for arg in args],
kwargs={
k: to_serialize(v)
for k, v in kwargs.items()
},
)
except OSError:
if self._future and not self._future.done():
await self._future
return await run_actor_function_on_worker()
else: # pragma: no cover
raise OSError("Unable to contact Actor's worker")
if result["status"] == "OK":
return _OK(result["result"])
return _Error(result["exception"])
actor_future = ActorFuture(io_loop=self._io_loop)
async def wait_then_set_result():
actor_future._set_result(await
run_actor_function_on_worker())
self._io_loop.add_callback(wait_then_set_result)
return actor_future
return func
else:
async def get_actor_attribute_from_worker():
x = await self._worker_rpc.actor_attribute(attribute=key,
actor=self.key)
if x["status"] == "OK":
return x["result"]
else:
raise x["exception"]
return self._sync(get_actor_attribute_from_worker)