def detail(worker: BaseWorker, protocol_tuple: tuple) -> "Protocol":
"""This function reconstructs a Protocol object given its attributes in the form of a tuple.
Args:
worker: the worker doing the deserialization
protocol_tuple: a tuple holding the attributes of the Protocol
Returns:
protocol: a Protocol object
"""
id, tags, description, plans_reference, workers_resolved = map(
lambda o: sy.serde._detail(worker, o), protocol_tuple
)
plans = []
for owner_id, plan_id in plans_reference:
if workers_resolved:
plan_owner = worker.get_worker(owner_id, fail_hard=True)
plan_pointer = worker.request_search(plan_id, location=plan_owner)[0]
worker.register_obj(plan_pointer)
plans.append((plan_owner, plan_pointer))
else:
try:
plan_owner = worker.get_worker(owner_id, fail_hard=True)
plan_pointer = worker.request_search(plan_id, location=plan_owner)[0]
plan = plan_pointer.get()
except WorkerNotFoundException:
plan = worker.get_obj(plan_id)
plans.append((worker.id, plan))
protocol = sy.Protocol(plans=plans, id=id, owner=worker, tags=tags, description=description)
return protocol
def detail(worker: AbstractWorker, protocol_tuple: tuple) -> "Protocol":
"""This function reconstructs a Protocol object given its attributes in the form of a tuple.
Args:
worker: the worker doing the deserialization
protocol_tuple: a tuple holding the attributes of the Protocol
Returns:
protocol: a Protocol object
"""
(id_, name, roles, tags, description) = protocol_tuple
id_ = sy.serde.msgpack.serde._detail(worker, id_)
name = sy.serde.msgpack.serde._detail(worker, name)
roles = sy.serde.msgpack.serde._detail(worker, roles)
tags = sy.serde.msgpack.serde._detail(worker, tags)
description = sy.serde.msgpack.serde._detail(worker, description)
return sy.Protocol(
id=id_,
name=name,
owner=worker,
roles=roles,
is_built=True,
tags=tags,
description=description,
)
def test_protocol_waiting_promise(hook, workers):
hook.local_worker.is_client_worker = False
alice = workers["alice"]
bob = workers["bob"]
@syft.func2plan(args_shape=[(1, )])
def plan_alice1(in_a):
return in_a + 1
@syft.func2plan(args_shape=[(1, )])
def plan_bob1(in_b):
return in_b + 2
@syft.func2plan(args_shape=[(1, )])
def plan_bob2(in_b):
return in_b + 3
@syft.func2plan(args_shape=[(1, )])
def plan_alice2(in_a):
return in_a + 4
protocol = syft.Protocol([("alice", plan_alice1), ("bob", plan_bob1),
("bob", plan_bob2), ("alice", plan_alice2)])
protocol.deploy(alice, bob)
x = syft.Promise.FloatTensor(shape=torch.Size((1, )))
in_ptr, res_ptr = protocol(x)
in_ptr.keep(torch.tensor([1.0]))
assert res_ptr.value().get() == 11
hook.local_worker.is_client_worker = True
def generateTwoWayProtocol(me):
@sy.func2plan(args_shape=[(1,)], state=(th.tensor([4.2, 7.3]), ))
def jasonPlan(x, state):
bias, = state.read()
y = x + bias
z = th.abs(y)
return z
@sy.func2plan(args_shape=[(1,)])
def andyPlan(x):
y = x + x
z = th.abs(y)
return z
protocol2 = sy.Protocol([("worker1", jasonPlan), ("worker2", andyPlan)])
# Simplify the protocol
protocolPb, simplifiedProtocol = serializeToBase64Pb(me, protocol2)
# Simplify jasonPlan
jasonPlanPb, simplifiedJasonPlan = serializeToBase64Pb(me, jasonPlan)
# Simplify andyPlan
andyPlanPb, simplifiedAndyPlan = serializeToBase64Pb(me, andyPlan)
return {
"protocol": str(simplifiedProtocol),
"_protocol": str(protocolPb),
"jason": str(simplifiedJasonPlan),
"_jason": str(jasonPlanPb),
"andy": str(simplifiedAndyPlan),
"_andy": str(andyPlanPb),
}
def _create_inc_protocol():
@sy.func2plan(args_shape=[(1, )])
def inc1(x):
return x + 1
@sy.func2plan(args_shape=[(1, )])
def inc2(x):
return x + 1
@sy.func2plan(args_shape=[(1, )])
def inc3(x):
return x + 1
protocol = sy.Protocol([("worker1", inc1), ("worker2", inc2),
("worker3", inc3)])
return protocol
def generateThreeWayProtocol(me):
@sy.func2plan(args_shape=[(1,)], state=(th.tensor([4.2, 7.3]), ))
def bobPlan(x, state):
bias, = state.read()
y = x + bias
z = th.abs(y)
return z
@sy.func2plan(args_shape=[(1,)])
def theoPlan(x):
y = x + x
z = th.abs(y)
return z
@sy.func2plan(args_shape=[(1,)])
def alicePlan(x):
y = x + x
z = th.abs(y)
return z
protocol = sy.Protocol([("worker1", bobPlan), ("worker2", theoPlan), ("worker3", alicePlan)])
# Simplify the protocol
protocolPb, simplifiedProtocol = serializeToBase64Pb(me, protocol)
# Simplify bobPlan
bobPlanPb, simplifiedBobPlan = serializeToBase64Pb(me, bobPlan)
# Simplify theoPlan
theoPlanPb, simplifiedTheoPlan = serializeToBase64Pb(me, theoPlan)
# Simplify alicePlan
alicePlanPb, simplifiedAlicePlan = serializeToBase64Pb(me, alicePlan)
return {
"protocol": str(simplifiedProtocol),
"_protocol": str(protocolPb),
"bob": str(simplifiedBobPlan),
"_bob": str(bobPlanPb),
"theo": str(simplifiedTheoPlan),
"_theo": str(theoPlanPb),
"alice": str(simplifiedAlicePlan),
"_alice": str(alicePlanPb),
}
def create_from_attributes(worker, id, tags, description, workers_resolved,
plans_assignments) -> "Protocol":
"""
This function reconstructs a Protocol object given its attributes.
Args:
worker: the worker doing the deserialization
id: Protocol id
tags: Protocol tags
description: Protocol description
workers_resolved: Flag whether workers are resolved
plans_assignments: List of workers/plans IDs
Returns:
protocol: a Protocol object
"""
plans = []
for owner_id, plan_id in plans_assignments:
if workers_resolved:
plan_owner = worker.get_worker(owner_id, fail_hard=True)
plan_pointer = worker.request_search(plan_id,
location=plan_owner)[0]
worker.register_obj(plan_pointer)
plans.append((plan_owner, plan_pointer))
else:
try:
plan_owner = worker.get_worker(owner_id, fail_hard=True)
except WorkerNotFoundException:
plan = worker.get_obj(plan_id)
else:
plan_pointer = worker.request_search(
plan_id, location=plan_owner)[0]
plan = plan_pointer.get()
plans.append((worker.id, plan))
protocol = sy.Protocol(plans=plans,
id=id,
owner=worker,
tags=tags,
description=description)
return protocol