def accept_or_deny_request(msg: AcceptOrDenyRequestMessage, node: AbstractNode,
verify_key: VerifyKey):
if verify_key is None:
raise ValueError(
"Can't process AcceptOrDenyRequestService without a specified verification key"
)
_msg: AcceptOrDenyRequestMessage = validate_type(
msg, AcceptOrDenyRequestMessage)
current_user = node.users.first(verify_key=verify_key.encode(
encoder=HexEncoder).decode("utf-8"))
_req = node.data_requests.first(id=str(_msg.request_id.value))
_can_triage_request = node.users.can_triage_requests(
user_id=current_user.id)
if _msg.accept:
if _req and _can_triage_request:
tmp_obj = node.store[UID.from_string(_req.object_id)]
tmp_obj.read_permissions[VerifyKey(_req.verify_key.encode("utf-8"),
encoder=HexEncoder)] = _req.id
node.store[UID.from_string(_req.object_id)] = tmp_obj
node.data_requests.set(request_id=_req.id, status="accepted")
else:
_req_owner = current_user.verify_key == _req.verify_key
if _req and (_can_triage_request or _req_owner):
node.data_requests.set(request_id=_req.id, status="denied")
def update_request_msg(
msg: DeleteRequestMessage,
node: AbstractNode,
verify_key: VerifyKey,
) -> DeleteRequestResponse:
# Get Payload Content
request_id = msg.content.get("request_id", None)
status = msg.content.get("status", None)
current_user_id = msg.content.get("current_user", None)
users = node.users
if not current_user_id:
current_user_id = users.first(verify_key=verify_key.encode(
encoder=HexEncoder).decode("utf-8")).id
# Check if status field is empty
missing_paramaters = not status
if missing_paramaters:
raise MissingRequestKeyError(
message="Invalid request payload, empty fields (status)!")
_req = node.data_requests.first(id=request_id)
if not _req:
raise RequestError
if status not in ["accepted", "denied"]:
raise InvalidParameterValueError(
message='Request status should be either "accepted" or "denied"')
_can_triage_request = node.users.can_triage_requests(
user_id=current_user_id)
_current_user_key = verify_key.encode(encoder=HexEncoder).decode("utf-8")
_req_owner = _current_user_key == _req.verify_key
if status == "accepted" and _can_triage_request:
tmp_obj = node.store[UID.from_string(_req.object_id)]
tmp_obj.read_permissions[VerifyKey(_req.verify_key.encode("utf-8"),
encoder=HexEncoder)] = _req.id
node.store[UID.from_string(_req.object_id)] = tmp_obj
node.data_requests.set(request_id=_req.id, status=status)
elif status == "denied" and (_can_triage_request or _req_owner):
node.data_requests.set(request_id=_req.id, status=status)
else:
raise AuthorizationError(
"You're not allowed to update Request information!")
return DeleteRequestResponse(
address=msg.reply_to,
status_code=200,
content={"msg": "Request Updated!"},
)
def get_tensor_msg(
msg: GetTensorMessage,
node: AbstractNode,
) -> GetTensorResponse:
try:
payload = msg.content
# Retrieve the dataset from node.store
key = UID.from_string(value=payload["tensor_id"])
tensor = node.store[key]
return GetTensorResponse(
address=msg.reply_to,
status_code=200,
content={
"tensor": {
"id": payload["tensor_id"],
"tags": tensor.tags,
"description": tensor.description,
}
},
)
except Exception as e:
return GetTensorResponse(
address=msg.reply_to,
status_code=200,
content={"error": str(e)},
)
def test_update():
OrderedDict = SyOrderedDict
with pytest.raises(TypeError):
OrderedDict().update([("a", 1), ("b", 2)], None) # too many args
pairs = [("a", 1), ("b", 2), ("c", 3), ("d", 4), ("e", 5)]
od = OrderedDict()
od.update(dict(pairs))
assertEqual(sorted(od.items()), pairs) # dict input
od = OrderedDict()
od.update(**dict(pairs))
assertEqual(sorted(od.items()), pairs) # kwds input
od = OrderedDict()
od.update(pairs)
assertEqual(list(od.items()), pairs) # pairs input
od = OrderedDict()
od.update([("a", 1), ("b", 2), ("c", 9), ("d", 4)], c=3, e=5)
assertEqual(list(od.items()), pairs) # mixed input
# Issue 9137: Named argument called 'other' or ''
# shouldn't be treated specially.
od = OrderedDict()
od = OrderedDict()
od.update(other={})
assertEqual(list(od.items()), [("other", {})])
# Make sure that direct calls to update do not clear previous contents
# add that updates items are not moved to the end
d = OrderedDict([("a", 1), ("b", 2), ("c", 3), ("d", 44), ("e", 55)])
d.update([("e", 5), ("f", 6)], g=7, d=4)
assertEqual(
list(d.items()),
[("a", 1), ("b", 2), ("c", 3), ("d", 4), ("e", 5), ("f", 6), ("g", 7)],
)
pytest.raises(TypeError, OrderedDict().update, 42)
pytest.raises(TypeError, OrderedDict().update, (), ())
d = OrderedDict(
[("a", 1), ("b", 2), ("c", 3), ("d", 44), ("e", 55)],
_id=UID.from_string(value="{12345678-1234-5678-1234-567812345678}"),
)
assert d.id.__eq__(
UID.from_string(value="{12345678-1234-5678-1234-567812345678}"))
def process(
node: AbstractNode,
msg: SaveObjectMessage,
verify_key: VerifyKey,
) -> None:
_obj_id = msg.content.get("uid", None)
_syft_id = UID.from_string(value=_obj_id)
try:
_obj = node.store[_syft_id]
except Exception:
raise Exception("Object Not Found!")
executor.submit(send_obj, _obj, node)
def get_all_requests(msg: GetAllRequestsMessage, node: AbstractNode,
verify_key: VerifyKey):
if verify_key is None:
raise ValueError("Can't process Request service without a given "
"verification key")
current_user = node.users.first(verify_key=verify_key.encode(
encoder=HexEncoder).decode("utf-8"))
_can_triage_request = node.users.can_triage_requests(
user_id=current_user.id)
_requests = node.data_requests.all()
if _can_triage_request:
_requests = node.data_requests.all()
else:
_requests = node.data_requests.query(verify_key=verify_key.encode(
encoder=HexEncoder).decode("utf-8"))
data_requests = [
RequestMessage(
request_id=UID.from_string(req.id),
request_description=req.reason,
address=node.address,
owner_address=node.address,
object_id=UID.from_string(req.object_id),
object_type=req.object_type,
object_tags=req.tags,
requester_verify_key=VerifyKey(req.verify_key.encode("utf-8"),
encoder=HexEncoder),
timeout_secs=None,
) for req in _requests
]
return GetAllRequestsResponseMessage(requests=data_requests,
address=msg.reply_to)
def update_tensor_msg(
msg: UpdateTensorMessage,
node: AbstractNode,
) -> UpdateTensorResponse:
try:
payload = msg.content
new_tensor = th.tensor(payload["tensor"])
new_tensor.tag(*payload.get("tags", []))
new_tensor.describe(payload.get("description", ""))
key = UID.from_string(value=payload["tensor_id"])
# Step 2: create message which contains object to send
storable = StorableObject(
id=key,
data=new_tensor,
tags=new_tensor.tags,
description=new_tensor.description,
search_permissions={VerifyAll(): None}
if payload.get("searchable", False)
else {},
)
obj_msg = SaveObjectAction(obj=storable, address=node.address)
signed_message = obj_msg.sign(
signing_key=SigningKey(
payload["internal_key"].encode("utf-8"), encoder=HexEncoder
)
)
node.recv_immediate_msg_without_reply(msg=signed_message)
return UpdateTensorResponse(
address=msg.reply_to,
status_code=200,
content={"msg": "Tensor modified succesfully!"},
)
except Exception as e:
return UpdateTensorResponse(
address=msg.reply_to,
status_code=200,
content={"error": str(e)},
)
def process(
node: AbstractNode,
msg: Union[
LoadObjectMessage,
],
verify_key: VerifyKey,
) -> Union[LoadObjectResponse, SaveObjectResponse,]:
_worker_address = msg.content.get("address", None)
_obj_id = msg.content.get("uid", None)
_current_user_id = msg.content.get("current_user", None)
users = node.users
if not _current_user_id:
_current_user_id = users.first(
verify_key=verify_key.encode(encoder=HexEncoder).decode("utf-8")
).id
addr_pb = Address_PB()
addr_pb.ParseFromString(_worker_address.encode("ISO-8859-1"))
_syft_address = _deserialize(blob=addr_pb)
_syft_id = UID.from_string(value=_obj_id)
_worker_client = node.in_memory_client_registry[_syft_address.domain_id]
try:
_obj = node.store[_syft_id]
except Exception:
raise Exception("Object Not Found!")
_obj.data.send(
_worker_client,
searchable=True,
tags=_obj.tags,
description=_obj.description,
)
return LoadObjectResponse(
address=msg.reply_to,
status_code=200,
content={"msg": "Object loaded successfully!"},
)
def del_tensor_msg(
msg: DeleteTensorMessage,
node: AbstractNode,
) -> DeleteTensorResponse:
try:
payload = msg.content
# Retrieve the dataset from node.store
key = UID.from_string(value=payload["tensor_id"])
node.store.delete(key=key)
return DeleteTensorResponse(
address=msg.reply_to,
status_code=200,
content={"msg": "Tensor deleted successfully!"},
)
except Exception as e:
return DeleteTensorResponse(
address=msg.reply_to,
success=False,
content={"error": str(e)},
)
def __getitem__(self, key: UID) -> StorableObject:
bin_obj = self.db.session.query(BinObject).filter_by(
id=str(key.value)).first()
obj_metadata = (self.db.session.query(ObjectMetadata).filter_by(
obj=str(key.value)).first())
if not bin_obj or not obj_metadata:
raise Exception("Object not found!")
read_permissions = {
VerifyKey(key.encode("utf-8"), encoder=HexEncoder): value
for key, value in obj_metadata.read_permissions.items()
}
obj = StorableObject(
id=UID.from_string(bin_obj.id),
data=bin_obj.object,
description=obj_metadata.description,
tags=obj_metadata.tags,
read_permissions=read_permissions,
search_permissions=syft.lib.python.Dict({VERIFYALL: None}),
)
return obj
def update_dataset(self, key: str, df_json: dict) -> dict:
_json = deepcopy(df_json)
json_obj = self.db.session.query(JsonObject).get(key)
bin_obj = self.db.session.query(BinaryObject).get(key)
mapping = []
# Separate CSV from metadata
for el in _json["tensors"].copy():
_id = UID()
_json["tensors"][el]["id"] = _id.value.hex
mapping.append((el, _id, _json["tensors"][el].pop("content",
None)))
# Create storables from UID/CSV
# Update metadata
storables = []
for idx, (name, _id, raw_file) in enumerate(mapping):
_tensor = pd.read_csv(StringIO(raw_file))
_tensor = th.tensor(_tensor.values.astype(np.float32))
_json["tensors"][name]["shape"] = [int(x) for x in _tensor.size()]
_json["tensors"][name]["dtype"] = "{}".format(_tensor.dtype)
storables.append(StorableObject(id=_id, data=_tensor))
# Ensure we have same ID in metadata and dataset
_id = json_obj.id
_id = UID.from_string(_id)
df = Dataset(id=_id, data=storables)
_json["id"] = _id.value.hex
metadata = get_metadata(self.db)
metadata.length += 1
setattr(bin_obj, "binary", serialize(df, to_bytes=True))
setattr(json_obj, "binary", _json)
self.db.session.commit()
return _json
def create_request_msg(
msg: CreateRequestMessage,
node: AbstractNode,
verify_key: VerifyKey,
) -> CreateRequestResponse:
# Get Payload Content
current_user_id = msg.content.get("current_user", None)
object_id = msg.content.get("object_id", None)
reason = msg.content.get("reason", None)
request_type = msg.content.get("request_type", None)
object_type = msg.content.get("object_type", "storable object")
users = node.users
if not current_user_id:
current_user = users.first(verify_key=verify_key.encode(
encoder=HexEncoder).decode("utf-8"))
else:
current_user = users.first(id=current_user_id)
# since we reject/accept requests based on the ID, we don't want there to be
# multiple requests with the same ID because this could cause security problems.
_duplicate_request = node.data_requests.contain(
object_id=object_id,
verify_key=verify_key.encode(encoder=HexEncoder).decode("utf-8"),
)
if _duplicate_request:
raise DuplicateRequestException("You have already requested {}".format(
msg.content["object_id"]))
# Check if object_id/reason/request_type fields are empty
missing_paramaters = not object_id or not reason or not request_type
if missing_paramaters:
raise MissingRequestKeyError(
message=
"Invalid request payload, empty fields (object_id/reason/request_type)!"
)
valid_paramaters = request_type == "permissions" or request_type == "budget"
if not valid_paramaters:
raise InvalidParameterValueError(
message='Request type should be either "permissions” or “budget”.')
requests = node.data_requests
object_uid = UID.from_string(object_id)
request_obj = requests.create_request(
user_id=current_user.id,
user_name=current_user.email,
object_id=object_id,
reason=reason,
request_type=request_type,
verify_key=verify_key.encode(encoder=HexEncoder).decode("utf-8"),
object_type=object_type,
tags=node.store[object_uid]._tags,
)
request_json = model_to_json(request_obj)
return CreateRequestResponse(
address=msg.reply_to,
status_code=200,
content=request_json,
)
def keys(self) -> KeysView[UID]:
keys = self.db.session.query(BinObject.id).all()
keys = [UID.from_string(k[0]) for k in keys]
return keys