def send_command(
self,
recipient: "BaseWorker",
cmd_name: str,
target: PointerTensor = None,
args_: tuple = (),
kwargs_: dict = {},
return_ids: str = None,
return_value: bool = False,
) -> Union[List[PointerTensor], PointerTensor]:
"""
Sends a command through a message to a recipient worker.
Args:
recipient: A recipient worker.
cmd_name: Command number.
target: Target pointer Tensor.
args_: additional args for command execution.
kwargs_: additional kwargs for command execution.
return_ids: A list of strings indicating the ids of the
tensors that should be returned as response to the command execution.
Returns:
A list of PointerTensors or a single PointerTensor if just one response is expected.
"""
if return_ids is None:
return_ids = (sy.ID_PROVIDER.pop(), )
try:
message = TensorCommandMessage.computation(cmd_name, target, args_,
kwargs_, return_ids,
return_value)
ret_val = self.send_msg(message, location=recipient)
except ResponseSignatureError as e:
ret_val = None
return_ids = e.ids_generated
if ret_val is None or type(ret_val) == bytes:
responses = []
for return_id in return_ids:
response = PointerTensor(
location=recipient,
id_at_location=return_id,
owner=self,
id=sy.ID_PROVIDER.pop(),
)
responses.append(response)
if return_value:
responses = [response.get() for response in responses]
if len(return_ids) == 1:
responses = responses[0]
else:
responses = tuple(responses)
else:
responses = ret_val
return responses
def _get_plan_output(self, result_ids, return_ptr=False):
responses = []
for return_id in result_ids:
response = PointerTensor(
location=self.owner, id_at_location=return_id, owner=self, id=sy.ID_PROVIDER.pop()
)
responses.append(response if return_ptr else response.get())
if len(responses) == 1:
return responses[0]
return responses
def test_build_rule_syft_tensors_and_pointers():
pointer = PointerTensor(id=1000,
location="location",
owner="owner",
garbage_collect_data=False)
result = hook_args.build_rule(([torch.tensor([1, 2]), pointer], 42))
assert result == ([1, 1], 0)
def test_pointer_tensor(hook, workers):
serde._apply_compress_scheme = serde.apply_no_compression
t = PointerTensor(
id=1000, location=workers["alice"], owner=workers["alice"], id_at_location=12345
)
t_serialized = serde.serialize(t)
t_serialized_deserialized = serde.deserialize(t_serialized)
assert t.id == t_serialized_deserialized.id
assert t.location.id == t_serialized_deserialized.location.id
assert t.id_at_location == t_serialized_deserialized.id_at_location
def test_pointer_found_exception(workers):
ptr_id = syft.ID_PROVIDER.pop()
pointer = PointerTensor(id=ptr_id, location=workers["alice"], owner=workers["me"])
try:
raise RemoteObjectFoundError(pointer)
except RemoteObjectFoundError as err:
err_pointer = err.pointer
assert isinstance(err_pointer, PointerTensor)
assert err_pointer.id == ptr_id
def test_pointer_tensor_simplify():
"""Test the simplification of PointerTensor"""
alice = syft.VirtualWorker(syft.torch.hook, id="alice")
input_tensor = PointerTensor(id=1000, location=alice, owner=alice)
output = serde._simplify(input_tensor)
assert output[1][0] == input_tensor.id
assert output[1][1] == input_tensor.id_at_location
assert output[1][2] == input_tensor.owner.id
def test_pointer_tensor_simplify(workers):
"""Test the simplification of PointerTensor"""
alice, me = workers["alice"], workers["me"]
input_tensor = PointerTensor(id=1000, location=alice, owner=alice)
output = msgpack.serde._simplify(me, input_tensor)
assert output[1][0] == input_tensor.id
assert output[1][1] == input_tensor.id_at_location
assert output[1][2] == msgpack.serde._simplify(me, input_tensor.owner.id)
async def async_send_command(
self,
message: tuple,
return_ids: str = None,
return_value: bool = False
) -> Union[List[PointerTensor], PointerTensor]:
"""
Sends a command through a message to the server part attached to the client
Args:
message: A tuple representing the message being sent.
return_ids: A list of strings indicating the ids of the
tensors that should be returned as response to the command execution.
Returns:
A list of PointerTensors or a single PointerTensor if just one response is expected.
Note: this is the async version of send_command, with the major difference that you
directly call it on the client worker (so we don't have the recipient kw argument)
"""
if return_ids is None:
return_ids = (sy.ID_PROVIDER.pop(), )
name, target, args_, kwargs_ = message
# Close the existing websocket connection in order to open a asynchronous connection
self.close()
try:
message = TensorCommandMessage.computation(name, target, args_,
kwargs_, return_ids,
return_value)
ret_val = await self.async_send_msg(message)
except ResponseSignatureError as e:
ret_val = None
return_ids = e.ids_generated
# Reopen the standard connection
self.connect()
if ret_val is None or type(ret_val) == bytes:
responses = []
for return_id in return_ids:
response = PointerTensor(
location=self,
id_at_location=return_id,
owner=sy.local_worker,
id=sy.ID_PROVIDER.pop(),
)
responses.append(response)
if len(return_ids) == 1:
responses = responses[0]
else:
responses = ret_val
return responses
def send_command(self,
recipient: "BaseWorker",
message: tuple,
return_ids: str = None
) -> Union[List[PointerTensor], PointerTensor]:
"""
Sends a command through a message to a recipient worker.
Args:
recipient: A recipient worker.
message: A tuple representing the message being sent.
return_ids: A list of strings indicating the ids of the
tensors that should be returned as response to the command execution.
Returns:
A list of PointerTensors or a single PointerTensor if just one response is expected.
"""
if return_ids is None:
return_ids = tuple([sy.ID_PROVIDER.pop()])
cmd_name = message[0]
cmd_owner = message[1]
cmd_args = message[2]
cmd_kwargs = message[3]
try:
ret_val = self.send_msg(
OperationMessage(cmd_name, cmd_owner, cmd_args, cmd_kwargs,
return_ids),
location=recipient,
)
except ResponseSignatureError as e:
ret_val = None
return_ids = e.ids_generated
if ret_val is None or type(ret_val) == bytes:
responses = []
for return_id in return_ids:
response = PointerTensor(
location=recipient,
id_at_location=return_id,
owner=self,
id=sy.ID_PROVIDER.pop(),
)
responses.append(response)
if len(return_ids) == 1:
responses = responses[0]
else:
responses = ret_val
return responses
def fetch_plan(self,
plan_id: Union[str, int],
location: "BaseWorker",
copy: bool = False) -> "Plan": # noqa: F821
"""Fetchs a copy of a the plan with the given `plan_id` from the worker registry.
This method is executed for local execution.
Args:
plan_id: A string indicating the plan id.
Returns:
A plan if a plan with the given `plan_id` exists. Returns None otherwise.
"""
message = PlanCommandMessage("fetch_plan", (plan_id, copy))
plan = self.send_msg(message, location=location)
plan.replace_worker_ids(location.id, self.id)
if plan.state_ids:
state_ids = []
for state_id in plan.state_ids:
if copy:
state_ptr = PointerTensor(
location=location,
id_at_location=state_id,
owner=self,
garbage_collect_data=False,
)
state_elem = state_ptr.copy().get()
else:
state_elem = self.request_obj(state_id, location)
self.register_obj(state_elem)
state_ids.append(state_elem.id)
plan.replace_ids(plan.state_ids, state_ids)
plan.state_ids = state_ids
return plan
def callback(grad):
assert isinstance(grad, torch.Tensor), "Grad in callback should be a Tensor"
# the grad tensor is created by the torch backprop and might not be registered properly
self.owner.register_obj(grad)
pointer = PointerTensor(
location=self.owner,
id_at_location=grad.id,
owner=location,
id=syft.ID_PROVIDER.pop(),
)
# update the message arguments
message.action.args = (pointer,)
self.owner.send_msg(message=message, location=location)
# De-register the grad after the callback has been handled
self.owner.de_register_obj(grad)
def test_raising_error_when_item_func_called(workers):
pointer = PointerTensor(id=1000,
location=workers["alice"],
owner=workers["me"])
with pytest.raises(RuntimeError):
pointer.item()
def test_init(workers):
alice, me = workers["alice"], workers["me"]
pointer = PointerTensor(id=1000, location=alice, owner=me)
pointer.__str__()
def test_init(workers):
pointer = PointerTensor(id=1000,
location=workers["alice"],
owner=workers["me"])
pointer.__str__()
