use lgwks_std::json::serde::{Deserialize, Serialize};
use super::super::ensure;
use super::{JsonValue, SourceKind};
use crate::canvas_protocol::SessionInvariant;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(crate = "lgwks_std::json::serde")]
#[non_exhaustive]
pub struct PredictionEnvelope {
signal_id: String,
kind: String,
source_id: String,
#[serde(deserialize_with = "check_ml_source")]
source_kind: SourceKind,
session_invariant: SessionInvariant,
payload: JsonValue,
emitted_at: String,
model_version: String,
confidence: f64,
reasoning: String,
view_directive: Option<JsonValue>,
}
fn check_ml_source<'de, D>(deserializer: D) -> Result<SourceKind, D::Error>
where
D: lgwks_std::json::serde::Deserializer<'de>,
{
let kind = SourceKind::deserialize(deserializer)?;
ensure(kind == SourceKind::Ml, || {
<D::Error as lgwks_std::json::serde::de::Error>::custom(
"PredictionEnvelope sourceKind must be ml",
)
})?;
Ok(kind)
}
impl PredictionEnvelope {
#[must_use]
pub fn new(
signal_id: String,
kind: String,
source_kind: SourceKind,
source_id: String,
emitted_at: String,
session_invariant: SessionInvariant,
payload: JsonValue,
) -> Self {
Self {
signal_id,
kind,
source_kind,
source_id,
emitted_at,
session_invariant,
payload,
model_version: String::new(),
confidence: 0.0,
reasoning: String::new(),
view_directive: None,
}
}
pub fn set_model_version(&mut self, model_version: String) {
self.model_version = model_version;
}
pub fn set_confidence(&mut self, confidence: f64) {
self.confidence = confidence;
}
pub fn set_reasoning(&mut self, reasoning: String) {
self.reasoning = reasoning;
}
pub fn set_view_directive(&mut self, view_directive: Option<JsonValue>) {
self.view_directive = view_directive;
}
#[must_use]
pub fn signal_id(&self) -> &str {
&self.signal_id
}
#[must_use]
pub const fn session_invariant(&self) -> &SessionInvariant {
&self.session_invariant
}
#[must_use]
pub const fn payload(&self) -> &JsonValue {
&self.payload
}
#[must_use]
pub fn kind(&self) -> &str {
&self.kind
}
#[must_use]
pub fn emitted_at(&self) -> &str {
&self.emitted_at
}
#[must_use]
pub fn source_id(&self) -> &str {
&self.source_id
}
#[must_use]
pub const fn source_kind(&self) -> SourceKind {
self.source_kind
}
#[must_use]
pub fn model_version(&self) -> &str {
&self.model_version
}
#[must_use]
pub const fn confidence(&self) -> f64 {
self.confidence
}
#[must_use]
pub fn reasoning(&self) -> &str {
&self.reasoning
}
#[must_use]
pub const fn view_directive(&self) -> Option<&JsonValue> {
self.view_directive.as_ref()
}
}