use std::collections::{BTreeMap, BTreeSet};
use std::path::PathBuf;
use serde::{Deserialize, Serialize};
use crate::configuration::ExecutionMode;
use crate::diagnostics::{Diagnostic, DiagnosticPath};
use crate::documents::AuthoredFormat;
use crate::ir::{
AssetReference, CellOutput, CellOutputKind, Fingerprint, Provenance, SourceLocation,
SourceSegment, SourceSpan,
};
use super::{EffectiveCellOptions, ExecutionDeadlines, ExecutionDefaults};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExecutionPage {
pub source: SourceLocation,
pub collection: String,
pub working_directory: Option<DiagnosticPath>,
pub source_fingerprint: Fingerprint,
pub format: AuthoredFormat,
pub mode: ExecutionMode,
pub page_veto: bool,
pub parser_version: String,
pub qmd_policy: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PageExecutionRecord {
pub page: ExecutionPage,
pub defaults: ExecutionDefaults,
pub cells: Vec<CellExecutionResult>,
pub diagnostics: Vec<Diagnostic>,
pub assets: Vec<ExecutionAsset>,
pub provenance: Option<PageExecutionProvenance>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CellExecutionResult {
pub ordinal: usize,
pub language: Option<String>,
pub span: SourceSpan,
pub source_segments: Vec<SourceSegment>,
pub submitted_source_fingerprint: Option<Fingerprint>,
pub options: EffectiveCellOptions,
pub outcome: CellOutcome,
pub outputs: Vec<ExecutionOutput>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum CellOutcome {
Ok,
AllowedError,
Skipped {
reason: CellSkipReason,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum CellSkipReason {
EvalFalse,
LanguageMismatch,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExecutionOutput {
pub owning_cell: usize,
pub producing_cell: usize,
pub updating_cell: Option<usize>,
pub slot: usize,
pub output: CellOutput,
pub offered_mime_types: BTreeSet<String>,
pub selected_mime_type: Option<String>,
pub representations: Vec<RepresentationEvidence>,
pub diagnostic_indices: Vec<usize>,
}
impl ExecutionOutput {
pub fn unsupported_placeholder(&self) -> Option<UnsupportedOutput<'_>> {
(matches!(self.output.kind, CellOutputKind::Display)
&& self.output.representations.is_empty()
&& self.representations.is_empty()
&& self.selected_mime_type.is_none()
&& !self.diagnostic_indices.is_empty())
.then_some(UnsupportedOutput {
mime_types: &self.offered_mime_types,
diagnostic_indices: &self.diagnostic_indices,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct UnsupportedOutput<'a> {
pub mime_types: &'a BTreeSet<String>,
pub diagnostic_indices: &'a [usize],
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RepresentationEvidence {
pub content_fingerprint: Fingerprint,
pub producing_cell: usize,
pub policy: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExecutionAsset {
pub reference: AssetReference,
pub media_type: String,
pub byte_size: u64,
}
#[derive(Debug, PartialEq, Eq)]
pub struct StagedExecutionAsset {
pub reference: AssetReference,
pub path: PathBuf,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PageExecutionProvenance {
pub execution: Provenance,
pub engine_build_fingerprint: Fingerprint,
pub components: BTreeMap<String, ExecutionComponent>,
pub policies: ExecutionPolicies,
pub kernel: KernelExecutionProvenance,
pub platform: ExecutionPlatform,
pub deadlines_ms: ExecutionDeadlines,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExecutionComponent {
pub name: String,
pub version: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExecutionPolicies {
pub execution: String,
pub mime: String,
pub html: String,
pub svg: String,
}
impl Default for ExecutionPolicies {
fn default() -> Self {
Self {
execution: "execution-mvp-v1".into(),
mime: "mime-mvp-v1".into(),
html: "html-mvp-v1".into(),
svg: "svg-mvp-v1".into(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct KernelExecutionProvenance {
pub spec_fingerprint: Fingerprint,
pub launch_fingerprint: Fingerprint,
pub search: Vec<KernelSearchLocation>,
pub interrupt_mode: KernelInterruptMode,
pub implementation: String,
pub protocol_version: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct KernelSearchLocation {
pub class: KernelSearchClass,
pub ordinal: usize,
pub selected: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum KernelSearchClass {
JupyterPath,
UserData,
SystemLocal,
System,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum KernelInterruptMode {
Signal,
Message,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExecutionPlatform {
pub os: String,
pub architecture: String,
pub target: String,
}