private void OnDisplayEvent(DisplayEventBase displayEvent,
ZeroMQMessage request,
IJupyterMessageSender jupyterMessageSender)
{
if (displayEvent is ReturnValueProduced && displayEvent.Value is DisplayedValue)
{
return;
}
var transient = CreateTransient(displayEvent.ValueId);
var formattedValues = displayEvent
.FormattedValues
.ToDictionary(k => k.MimeType, v => PreserveJson(v.MimeType, v.Value));
var value = displayEvent.Value;
PubSubMessage dataMessage;
switch (displayEvent)
{
case DisplayedValueProduced _:
dataMessage = new DisplayData(
transient: transient,
data: formattedValues);
break;
case DisplayedValueUpdated _:
dataMessage = new UpdateDisplayData(
transient: transient,
data: formattedValues);
break;
case ReturnValueProduced _:
dataMessage = new ExecuteResult(
_executionCount,
transient: transient,
data: formattedValues);
break;
case StandardOutputValueProduced _:
dataMessage = Stream.StdOut(GetPlainTextValueOrDefault(formattedValues, value?.ToString() ?? string.Empty));
break;
case StandardErrorValueProduced _:
case ErrorProduced _:
dataMessage = Stream.StdErr(GetPlainTextValueOrDefault(formattedValues, value?.ToString() ?? string.Empty));
break;
default:
throw new ArgumentException("Unsupported event type", nameof(displayEvent));
}
var isSilent = ((ExecuteRequest)request.Content).Silent;
if (!isSilent)
{
// send on io
jupyterMessageSender.Send(dataMessage);
}
}
public void Update_data_contract_has_not_been_broken()
{
var socket = new TextSocket();
var sender = new MessageSender(socket, new SignatureValidator("key", "HMACSHA256"));
var transient = new Dictionary <string, object> {
{ "display_id", "none" }
};
var output = "some result";
var displayData = new UpdateDisplayData
(
data: new Dictionary <string, object>
{
{ "text/html", output },
{ "text/plain", output }
},
transient: transient
);
var header = new Header(messageType: JupyterMessageContentTypes.UpdateDisplayData, messageId: Guid.Empty.ToString(),
version: "5.3", username: Constants.USERNAME, session: "test session",
date: DateTime.MinValue.ToString("yyyy-MM-ddTHH:mm:ssZ"));
var replyMessage = new Message(header, content: displayData);
sender.Send(replyMessage);
var encoded = socket.GetEncodedMessage();
this.Assent(encoded, _configuration);
}
private void OnValueProductionEvent(ValueProducedEventBase eventBase)
{
if (!InFlightRequests.TryGetValue(eventBase.GetRootCommand(), out var openRequest))
{
return;
}
var transient = CreateTransient(eventBase.ValueId);
var formattedValues = eventBase
.FormattedValues
.ToDictionary(k => k.MimeType, v => v.Value);
var value = eventBase.Value;
CreateDefaultFormattedValueIfEmpty(formattedValues, value);
DisplayData executeResultData;
switch (eventBase)
{
case DisplayedValueProduced _:
executeResultData = new DisplayData(
transient: transient,
data: formattedValues);
break;
case ReturnValueProduced _:
executeResultData = new ExecuteResult(
openRequest.ExecutionCount,
transient: transient,
data: formattedValues);
break;
case DisplayedValueUpdated _:
executeResultData = new UpdateDisplayData(
transient: transient,
data: formattedValues);
break;
default:
throw new ArgumentException("Unsupported event type", nameof(eventBase));
}
SendDisplayData(executeResultData, openRequest);
}
private void OnValueProduced(
ValueProducedEventBase valueProduced,
Message request,
IMessageSender ioPubChannel)
{
var transient = CreateTransient(valueProduced.ValueId);
var formattedValues = valueProduced
.FormattedValues
.ToDictionary(k => k.MimeType, v => v.Value);
var value = valueProduced.Value;
CreateDefaultFormattedValueIfEmpty(formattedValues, value);
JupyterMessageContent executeResultData;
switch (valueProduced)
{
case DisplayedValueProduced _:
executeResultData = new DisplayData(
transient: transient,
data: formattedValues);
break;
case ReturnValueProduced _:
executeResultData = new ExecuteResult(
_executionCount,
transient: transient,
data: formattedValues);
break;
case DisplayedValueUpdated _:
executeResultData = new UpdateDisplayData(
transient: transient,
data: formattedValues);
break;
default:
throw new ArgumentException("Unsupported event type", nameof(valueProduced));
}
SendDisplayData(executeResultData, request, ioPubChannel);
}
private void OnDisplayEvent(DisplayEventBase displayEvent,
Envelope request,
IJupyterMessageSender jupyterMessageSender)
{
var transient = CreateTransient(displayEvent.ValueId);
var formattedValues = displayEvent
.FormattedValues
.ToDictionary(k => k.MimeType, v => v.Value);
var value = displayEvent.Value;
CreateDefaultFormattedValueIfEmpty(formattedValues, value);
PubSubMessage executeResultData;
switch (displayEvent)
{
case DisplayedValueProduced _:
executeResultData = new DisplayData(
transient: transient,
data: formattedValues);
break;
case DisplayedValueUpdated _:
executeResultData = new UpdateDisplayData(
transient: transient,
data: formattedValues);
break;
case ReturnValueProduced _:
executeResultData = new ExecuteResult(
_executionCount,
transient: transient,
data: formattedValues);
break;
default:
throw new ArgumentException("Unsupported event type", nameof(displayEvent));
}
SendDisplayData(executeResultData, request, jupyterMessageSender);
}
public void Update_data_contract_has_not_been_broken()
{
var socket = new TextSocket();
var sender = new MessageSender(socket, new SignatureValidator("key", "HMACSHA256"));
var transient = new Dictionary <string, object> {
{ "display_id", "none" }
};
var output = "some result";
var displayData = new UpdateDisplayData()
{
Data = new JObject
{
{ "text/html", output },
{ "text/plain", output }
},
Transient = transient
};
var header = new Header
{
Username = Constants.USERNAME,
Session = "test session",
MessageId = Guid.Empty.ToString(),
MessageType = MessageTypeValues.UpdateDisplayData,
Date = DateTime.MinValue.ToString("yyyy-MM-ddTHH:mm:ssZ"),
Version = "5.3"
};
var replyMessage = new Message
{
Header = header,
Content = displayData
};
sender.Send(replyMessage);
var encoded = socket.GetEncodedMessage();
this.Assent(encoded, _configuration);
}
private void OnDisplayEvent(DisplayEvent displayEvent,
ZeroMQMessage request,
IJupyterMessageSender jupyterMessageSender)
{
if (displayEvent is ReturnValueProduced && displayEvent.Value is DisplayedValue)
{
return;
}
var transient = CreateTransient(displayEvent.ValueId);
// Currently there is at most one formatted value with at most
// and we return a dictionary for JSON formatting keyed by that mime type
//
// In the case of DiagnosticsProduced however there are multiple entries, one
// for each diagnsotic, all with the same type
Dictionary <string, object> GetFormattedValuesByMimeType()
{
return
(displayEvent
.FormattedValues
.ToDictionary(k => k.MimeType, v => PreserveJson(v.MimeType, v.Value)));
}
var value = displayEvent.Value;
PubSubMessage dataMessage = null;
switch (displayEvent)
{
case DisplayedValueProduced _:
dataMessage = new DisplayData(
transient: transient,
data: GetFormattedValuesByMimeType());
break;
case DisplayedValueUpdated _:
dataMessage = new UpdateDisplayData(
transient: transient,
data: GetFormattedValuesByMimeType());
break;
case ReturnValueProduced _:
dataMessage = new ExecuteResult(
_executionCount,
transient: transient,
data: GetFormattedValuesByMimeType());
break;
case StandardOutputValueProduced _:
dataMessage = Stream.StdOut(GetPlainTextValueOrDefault(GetFormattedValuesByMimeType(), value?.ToString() ?? string.Empty));
break;
case StandardErrorValueProduced _:
case ErrorProduced _:
dataMessage = Stream.StdErr(GetPlainTextValueOrDefault(GetFormattedValuesByMimeType(), value?.ToString() ?? string.Empty));
break;
default:
throw new ArgumentException("Unsupported event type", nameof(displayEvent));
}
var isSilent = ((ExecuteRequest)request.Content).Silent;
if (!isSilent)
{
// send on io
jupyterMessageSender.Send(dataMessage);
}
}
