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