tstring-bindings 0.2.1__tar.gz → 0.2.2__tar.gz

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/Cargo.lock

@@ -725,7 +725,7 @@ checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
 
 [[package]]
 name = "tstring-backend-e2e-tests"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "tstring-json",
  "tstring-syntax",
@@ -735,7 +735,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-bindings"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "pyo3",
  "pythonize",
@@ -751,7 +751,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-json"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "serde_json",
  "toml",
@@ -760,7 +760,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-pyo3-bindings"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "criterion",
  "pyo3",
@@ -776,14 +776,14 @@ dependencies = [
 
 [[package]]
 name = "tstring-syntax"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "num-bigint",
 ]
 
 [[package]]
 name = "tstring-toml"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "serde_json",
  "toml",
@@ -792,7 +792,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-yaml"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "saphyr",
  "saphyr-parser",
@@ -803,7 +803,7 @@ dependencies = [
 
 [[package]]
 name = "tstring-yaml-pyo3-tests"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "pyo3",
  "saphyr",

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/Cargo.toml

@@ -9,7 +9,7 @@ homepage = "https://github.com/koxudaxi/tstring-structured-data"
 license = "MIT"
 repository = "https://github.com/koxudaxi/tstring-structured-data"
 rust-version = "1.94.0"
-version = "0.2.1"
+version = "0.2.2"
 
 [workspace.dependencies]
 num-bigint = "0.4.6"

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tstring-bindings
-Version: 0.2.1
+Version: 0.2.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/json-tstring-rs/Cargo.toml

@@ -18,7 +18,7 @@ test = false
 
 [dependencies]
 serde_json = { workspace = true }
-tstring-syntax = { version = "0.2.1", path = "../tstring-core-rs" }
+tstring-syntax = { version = "0.2.2", path = "../tstring-core-rs" }
 
 [dev-dependencies]
 toml = { workspace = true }

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/json-tstring-rs/src/lib.rs

@@ -1,10 +1,15 @@
 use serde_json::Value;
 use std::str::FromStr;
 use tstring_syntax::{
-    BackendError, BackendResult, NormalizedDocument, NormalizedFloat, NormalizedKey,
-    NormalizedStream, NormalizedValue, SourcePosition, SourceSpan, StreamItem, TemplateInput,
+    BackendError, BackendResult, InterpolationTypeRequirement, NormalizedDocument, NormalizedFloat,
+    NormalizedKey, NormalizedStream, NormalizedValue, SourcePosition, SourceSpan, StreamItem,
+    TemplateInput,
 };
 
+const JSON_VALUE_PYTHON_TYPE: &str =
+    "str | int | float | bool | None | dict[str, object] | list[object]";
+const STRING_PYTHON_TYPE: &str = "str";
+
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum JsonProfile {
     Rfc8259,
@@ -636,6 +641,99 @@ pub fn check_template(template: &TemplateInput) -> BackendResult<()> {
     check_template_with_profile(template, JsonProfile::default())
 }
 
+pub fn interpolation_type_requirements_with_profile(
+    template: &TemplateInput,
+    profile: JsonProfile,
+) -> BackendResult<Vec<InterpolationTypeRequirement>> {
+    let document = parse_validated_template_with_profile(template, profile)?;
+    let mut requirements = Vec::new();
+    collect_json_value_type_requirements(&document.value, &mut requirements);
+    requirements.sort_by_key(|requirement| requirement.interpolation_index);
+    Ok(requirements)
+}
+
+pub fn interpolation_type_requirements(
+    template: &TemplateInput,
+) -> BackendResult<Vec<InterpolationTypeRequirement>> {
+    interpolation_type_requirements_with_profile(template, JsonProfile::default())
+}
+
+fn collect_json_value_type_requirements(
+    value: &JsonValueNode,
+    requirements: &mut Vec<InterpolationTypeRequirement>,
+) {
+    match value {
+        JsonValueNode::String(node) => {
+            collect_json_string_type_requirements(node, requirements);
+        }
+        JsonValueNode::Literal(_) => {}
+        JsonValueNode::Interpolation(node) => {
+            requirements.push(json_type_requirement(node));
+        }
+        JsonValueNode::Object(node) => {
+            for member in &node.members {
+                collect_json_key_type_requirements(&member.key, requirements);
+                collect_json_value_type_requirements(&member.value, requirements);
+            }
+        }
+        JsonValueNode::Array(node) => {
+            for item in &node.items {
+                collect_json_value_type_requirements(item, requirements);
+            }
+        }
+    }
+}
+
+fn collect_json_key_type_requirements(
+    key: &JsonKeyNode,
+    requirements: &mut Vec<InterpolationTypeRequirement>,
+) {
+    match &key.value {
+        JsonKeyValue::String(node) => {
+            collect_json_string_type_requirements(node, requirements);
+        }
+        JsonKeyValue::Interpolation(node) => {
+            requirements.push(json_type_requirement(node));
+        }
+    }
+}
+
+fn collect_json_string_type_requirements(
+    string: &JsonStringNode,
+    requirements: &mut Vec<InterpolationTypeRequirement>,
+) {
+    for chunk in &string.chunks {
+        if let JsonStringPart::Interpolation(node) = chunk {
+            requirements.push(json_type_requirement(node));
+        }
+    }
+}
+
+fn json_type_requirement(node: &JsonInterpolationNode) -> InterpolationTypeRequirement {
+    match node.role.as_str() {
+        "value" => InterpolationTypeRequirement::new(
+            node.interpolation_index,
+            JSON_VALUE_PYTHON_TYPE,
+            "json value",
+        ),
+        "key" => InterpolationTypeRequirement::new(
+            node.interpolation_index,
+            STRING_PYTHON_TYPE,
+            "json object key",
+        ),
+        "string_fragment" => InterpolationTypeRequirement::new(
+            node.interpolation_index,
+            STRING_PYTHON_TYPE,
+            "json string fragment",
+        ),
+        _ => InterpolationTypeRequirement::new(
+            node.interpolation_index,
+            JSON_VALUE_PYTHON_TYPE,
+            "json interpolation",
+        ),
+    }
+}
+
 pub fn format_template_with_profile(
     template: &TemplateInput,
     profile: JsonProfile,

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/json-tstring-rs/tests/parser.rs

@@ -1,8 +1,10 @@
 use tstring_json::{
-    JsonKeyValue, JsonStringPart, JsonValueNode, check_template, format_template, parse_template,
-    parse_validated_template, validate_template,
+    JsonKeyValue, JsonStringPart, JsonValueNode, check_template, format_template,
+    interpolation_type_requirements, parse_template, parse_validated_template, validate_template,
+};
+use tstring_syntax::{
+    InterpolationTypeRequirement, TemplateInput, TemplateInterpolation, TemplateSegment,
 };
-use tstring_syntax::{TemplateInput, TemplateInterpolation, TemplateSegment};
 
 fn interpolation(index: usize, expression: &str) -> TemplateSegment {
     TemplateSegment::Interpolation(TemplateInterpolation {
@@ -69,6 +71,32 @@ fn checks_valid_json_templates() {
     check_template(&template).expect("expected check success");
 }
 
+#[test]
+fn reports_contextual_interpolation_type_requirements() {
+    let template = TemplateInput::from_segments(vec![
+        TemplateSegment::StaticText("{".to_owned()),
+        interpolation(0, "key"),
+        TemplateSegment::StaticText(": ".to_owned()),
+        interpolation(1, "value"),
+        TemplateSegment::StaticText(", \"label\": \"".to_owned()),
+        interpolation(2, "label"),
+        TemplateSegment::StaticText("\"}".to_owned()),
+    ]);
+
+    assert_eq!(
+        interpolation_type_requirements(&template).expect("expected type requirements"),
+        vec![
+            InterpolationTypeRequirement::new(0, "str", "json object key"),
+            InterpolationTypeRequirement::new(
+                1,
+                "str | int | float | bool | None | dict[str, object] | list[object]",
+                "json value"
+            ),
+            InterpolationTypeRequirement::new(2, "str", "json string fragment"),
+        ]
+    );
+}
+
 #[test]
 fn validates_json_templates_with_supported_interpolations() {
     let template = TemplateInput::from_segments(vec![

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tstring-bindings"
-version = "0.2.1"
+version = "0.2.2"
 description = "Native Python bindings for t-string structured data backends"
 readme = "README.md"
 license = { text = "MIT" }

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/python-bindings/Cargo.toml

@@ -24,12 +24,12 @@ pyo3 = { workspace = true, features = ["abi3-py314"] }
 pythonize = { workspace = true }
 saphyr = { workspace = true }
 serde_json = { workspace = true }
-tstring-json = { version = "0.2.1", path = "../json-tstring-rs" }
-tstring-pyo3-bindings = { version = "0.2.1", path = "../tstring-pyo3-bindings" }
-tstring-syntax = { version = "0.2.1", path = "../tstring-core-rs" }
+tstring-json = { version = "0.2.2", path = "../json-tstring-rs" }
+tstring-pyo3-bindings = { version = "0.2.2", path = "../tstring-pyo3-bindings" }
+tstring-syntax = { version = "0.2.2", path = "../tstring-core-rs" }
 toml = { workspace = true }
-tstring-toml = { version = "0.2.1", path = "../toml-tstring-rs" }
-tstring-yaml = { version = "0.2.1", path = "../yaml-tstring-rs" }
+tstring-toml = { version = "0.2.2", path = "../toml-tstring-rs" }
+tstring-yaml = { version = "0.2.2", path = "../yaml-tstring-rs" }
 
 [dev-dependencies]
 pyo3 = { workspace = true, features = ["auto-initialize"] }

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/python-bindings/src/lib.rs

@@ -627,7 +627,7 @@ fn normalized_offset_to_python(py: Python<'_>, offset_minutes: i16) -> PyResult<
 
 #[pymodule]
 fn tstring_bindings(py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
-    module.add("__version__", "0.2.1")?;
+    module.add("__version__", "0.2.2")?;
     module.add("__contract_version__", CONTRACT_VERSION)?;
     module.add("__contract_symbols__", PyTuple::new(py, CONTRACT_SYMBOLS)?)?;
     module.add("TemplateError", py.get_type::<TemplateError>())?;

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/toml-tstring-rs/Cargo.toml

@@ -19,4 +19,4 @@ test = false
 [dependencies]
 serde_json = { workspace = true }
 toml = { workspace = true }
-tstring-syntax = { version = "0.2.1", path = "../tstring-core-rs" }
+tstring-syntax = { version = "0.2.2", path = "../tstring-core-rs" }

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/toml-tstring-rs/src/lib.rs

@@ -1,10 +1,13 @@
 use tstring_syntax::{
-    BackendError, BackendResult, NormalizedDate, NormalizedDocument, NormalizedEntry,
-    NormalizedFloat, NormalizedKey, NormalizedLocalDateTime, NormalizedOffsetDateTime,
-    NormalizedStream, NormalizedTemporal, NormalizedTime, NormalizedValue, SourcePosition,
-    SourceSpan, StreamItem, TemplateInput,
+    BackendError, BackendResult, InterpolationTypeRequirement, NormalizedDate, NormalizedDocument,
+    NormalizedEntry, NormalizedFloat, NormalizedKey, NormalizedLocalDateTime,
+    NormalizedOffsetDateTime, NormalizedStream, NormalizedTemporal, NormalizedTime,
+    NormalizedValue, SourcePosition, SourceSpan, StreamItem, TemplateInput,
 };
 
+const TOML_VALUE_PYTHON_TYPE: &str = "str | int | float | bool | datetime.date | datetime.time | datetime.datetime | list[object] | dict[str, object]";
+const STRING_PYTHON_TYPE: &str = "str";
+
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum TomlProfile {
     V1_0,
@@ -1146,6 +1149,107 @@ pub fn check_template(template: &TemplateInput) -> BackendResult<()> {
     check_template_with_profile(template, TomlProfile::default())
 }
 
+pub fn interpolation_type_requirements_with_profile(
+    template: &TemplateInput,
+    profile: TomlProfile,
+) -> BackendResult<Vec<InterpolationTypeRequirement>> {
+    let document = parse_validated_template_with_profile(template, profile)?;
+    let mut requirements = Vec::new();
+    collect_toml_document_type_requirements(&document, &mut requirements);
+    requirements.sort_by_key(|requirement| requirement.interpolation_index);
+    Ok(requirements)
+}
+
+pub fn interpolation_type_requirements(
+    template: &TemplateInput,
+) -> BackendResult<Vec<InterpolationTypeRequirement>> {
+    interpolation_type_requirements_with_profile(template, TomlProfile::default())
+}
+
+fn collect_toml_document_type_requirements(
+    document: &TomlDocumentNode,
+    requirements: &mut Vec<InterpolationTypeRequirement>,
+) {
+    for statement in &document.statements {
+        match statement {
+            TomlStatementNode::Assignment(node) => {
+                collect_toml_key_path_type_requirements(&node.key_path, requirements);
+                collect_toml_value_type_requirements(&node.value, requirements);
+            }
+            TomlStatementNode::TableHeader(node) => {
+                collect_toml_key_path_type_requirements(&node.key_path, requirements);
+            }
+            TomlStatementNode::ArrayTableHeader(node) => {
+                collect_toml_key_path_type_requirements(&node.key_path, requirements);
+            }
+        }
+    }
+}
+
+fn collect_toml_key_path_type_requirements(
+    key_path: &TomlKeyPathNode,
+    requirements: &mut Vec<InterpolationTypeRequirement>,
+) {
+    for segment in &key_path.segments {
+        match &segment.value {
+            TomlKeySegmentValue::Bare(_) => {}
+            TomlKeySegmentValue::String(node) => {
+                collect_toml_string_type_requirements(node, requirements);
+            }
+            TomlKeySegmentValue::Interpolation(node) => {
+                requirements.push(InterpolationTypeRequirement::new(
+                    node.interpolation_index,
+                    STRING_PYTHON_TYPE,
+                    "toml key",
+                ));
+            }
+        }
+    }
+}
+
+fn collect_toml_value_type_requirements(
+    value: &TomlValueNode,
+    requirements: &mut Vec<InterpolationTypeRequirement>,
+) {
+    match value {
+        TomlValueNode::String(node) => collect_toml_string_type_requirements(node, requirements),
+        TomlValueNode::Literal(_) => {}
+        TomlValueNode::Interpolation(node) => {
+            requirements.push(InterpolationTypeRequirement::new(
+                node.interpolation_index,
+                TOML_VALUE_PYTHON_TYPE,
+                "toml value",
+            ));
+        }
+        TomlValueNode::Array(node) => {
+            for item in &node.items {
+                collect_toml_value_type_requirements(item, requirements);
+            }
+        }
+        TomlValueNode::InlineTable(node) => {
+            for entry in &node.entries {
+                collect_toml_key_path_type_requirements(&entry.key_path, requirements);
+                collect_toml_value_type_requirements(&entry.value, requirements);
+            }
+        }
+    }
+}
+
+fn collect_toml_string_type_requirements(
+    string: &TomlStringNode,
+    requirements: &mut Vec<InterpolationTypeRequirement>,
+) {
+    for chunk in &string.chunks {
+        if let TomlStringPart::Interpolation(node) = chunk {
+            requirements.push(InterpolationTypeRequirement::new(
+                node.interpolation_index,
+                STRING_PYTHON_TYPE,
+                "toml string fragment",
+            ));
+        }
+    }
+}
+
 pub fn format_template_with_profile(
     template: &TemplateInput,
     profile: TomlProfile,

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/toml-tstring-rs/tests/parser.rs

@@ -1,7 +1,9 @@
-use tstring_syntax::{TemplateInput, TemplateInterpolation, TemplateSegment};
+use tstring_syntax::{
+    InterpolationTypeRequirement, TemplateInput, TemplateInterpolation, TemplateSegment,
+};
 use tstring_toml::{
-    TomlStatementNode, TomlValueNode, check_template, format_template, parse_template,
-    parse_validated_template, validate_template,
+    TomlStatementNode, TomlValueNode, check_template, format_template,
+    interpolation_type_requirements, parse_template, parse_validated_template, validate_template,
 };
 
 fn interpolation(index: usize, expression: &str) -> TemplateSegment {
@@ -83,6 +85,41 @@ fn validates_toml_templates_with_supported_interpolations() {
     parse_validated_template(&template).expect("expected validated parse success");
 }
 
+#[test]
+fn reports_contextual_interpolation_type_requirements() {
+    let template = TemplateInput::from_segments(vec![
+        interpolation(0, "table"),
+        TemplateSegment::StaticText(".title = ".to_owned()),
+        interpolation(1, "value"),
+        TemplateSegment::StaticText("\nmessage = \"Hello ".to_owned()),
+        interpolation(2, "fragment"),
+        TemplateSegment::StaticText("\"\nmeta = { ".to_owned()),
+        interpolation(3, "inline_key"),
+        TemplateSegment::StaticText(" = ".to_owned()),
+        interpolation(4, "inline_value"),
+        TemplateSegment::StaticText(" }\n".to_owned()),
+    ]);
+
+    assert_eq!(
+        interpolation_type_requirements(&template).expect("expected type requirements"),
+        vec![
+            InterpolationTypeRequirement::new(0, "str", "toml key"),
+            InterpolationTypeRequirement::new(
+                1,
+                "str | int | float | bool | datetime.date | datetime.time | datetime.datetime | list[object] | dict[str, object]",
+                "toml value"
+            ),
+            InterpolationTypeRequirement::new(2, "str", "toml string fragment"),
+            InterpolationTypeRequirement::new(3, "str", "toml key"),
+            InterpolationTypeRequirement::new(
+                4,
+                "str | int | float | bool | datetime.date | datetime.time | datetime.datetime | list[object] | dict[str, object]",
+                "toml value"
+            ),
+        ]
+    );
+}
+
 #[test]
 fn formats_toml_templates_with_raw_interpolations() {
     let template = TemplateInput::from_segments(vec![

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/tstring-core-rs/src/lib.rs

@@ -176,6 +176,28 @@ impl std::error::Error for BackendError {}
 
 pub type BackendResult<T> = Result<T, BackendError>;
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct InterpolationTypeRequirement {
+    pub interpolation_index: usize,
+    pub expected_python_type: String,
+    pub expected_description: String,
+}
+
+impl InterpolationTypeRequirement {
+    #[must_use]
+    pub fn new(
+        interpolation_index: usize,
+        expected_python_type: impl Into<String>,
+        expected_description: impl Into<String>,
+    ) -> Self {
+        Self {
+            interpolation_index,
+            expected_python_type: expected_python_type.into(),
+            expected_description: expected_description.into(),
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct NormalizedStream {
     pub documents: Vec<NormalizedDocument>,

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/tstring-pyo3-bindings/Cargo.toml

@@ -16,10 +16,10 @@ serde_json = { workspace = true }
 saphyr = { workspace = true }
 saphyr-parser = { workspace = true }
 toml = { workspace = true }
-tstring-json = { version = "0.2.1", path = "../json-tstring-rs" }
-tstring-syntax = { version = "0.2.1", path = "../tstring-core-rs" }
-tstring-toml = { version = "0.2.1", path = "../toml-tstring-rs" }
-tstring-yaml = { version = "0.2.1", path = "../yaml-tstring-rs" }
+tstring-json = { version = "0.2.2", path = "../json-tstring-rs" }
+tstring-syntax = { version = "0.2.2", path = "../tstring-core-rs" }
+tstring-toml = { version = "0.2.2", path = "../toml-tstring-rs" }
+tstring-yaml = { version = "0.2.2", path = "../yaml-tstring-rs" }
 
 [dev-dependencies]
 criterion = "0.8.2"

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/tstring-pyo3-bindings/benches/render_paths.rs

@@ -11,7 +11,7 @@ fn benchmark_json_metadata_render(criterion: &mut Criterion) {
         let module = PyModule::from_code(
             py,
             pyo3::ffi::c_str!(
-                "value=3.14159\nlabel='service'\nitems=[1, 2, 3]\nmeta={'region': 'us-east-1', 'count': 3}\ntemplate=t'{\"format\": {value:.2f}, \"label\": \"{label!s}\", \"items\": {items}, \"meta\": {meta}, \"fragment\": \"pi={value:.2f}\"}'\n"
+                "value=3.14159\nlabel='service'\nitems=[1, 2, 3]\nmeta={'region': 'us-east-1', 'count': 3}\ntemplate=t'{{\"format\": {value:.2f}, \"label\": \"{label!s}\", \"items\": {items}, \"meta\": {meta}, \"fragment\": \"pi={value:.2f}\"}}'\n"
             ),
             pyo3::ffi::c_str!("bench_json_metadata.py"),
             pyo3::ffi::c_str!("bench_json_metadata"),
@@ -26,7 +26,13 @@ fn benchmark_json_metadata_render(criterion: &mut Criterion) {
     criterion.bench_function("json_metadata_render", |bench| {
         bench.iter(|| {
             Python::with_gil(|py| {
-                json_backend::render_document(py, &template, node.as_ref()).unwrap();
+                json_backend::render_document(
+                    py,
+                    &template,
+                    tstring_json::JsonProfile::default(),
+                    node.as_ref(),
+                )
+                .unwrap();
             });
         });
     });
@@ -52,7 +58,13 @@ fn benchmark_toml_metadata_render(criterion: &mut Criterion) {
     criterion.bench_function("toml_metadata_render", |bench| {
         bench.iter(|| {
             Python::with_gil(|py| {
-                toml_backend::render_document(py, &template, node.as_ref()).unwrap();
+                toml_backend::render_document(
+                    py,
+                    &template,
+                    tstring_toml::TomlProfile::default(),
+                    node.as_ref(),
+                )
+                .unwrap();
             });
         });
     });
@@ -78,7 +90,13 @@ fn benchmark_toml_dynamic_header_render(criterion: &mut Criterion) {
     criterion.bench_function("toml_dynamic_header_render", |bench| {
         bench.iter(|| {
             Python::with_gil(|py| {
-                toml_backend::render_document(py, &template, node.as_ref()).unwrap();
+                toml_backend::render_document(
+                    py,
+                    &template,
+                    tstring_toml::TomlProfile::default(),
+                    node.as_ref(),
+                )
+                .unwrap();
             });
         });
     });
@@ -104,7 +122,13 @@ fn benchmark_yaml_metadata_render(criterion: &mut Criterion) {
     criterion.bench_function("yaml_metadata_render", |bench| {
         bench.iter(|| {
             Python::with_gil(|py| {
-                yaml_backend::render_document(py, &template, node.as_ref()).unwrap();
+                yaml_backend::render_document(
+                    py,
+                    &template,
+                    tstring_yaml::YamlProfile::default(),
+                    node.as_ref(),
+                )
+                .unwrap();
             });
         });
     });

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/yaml-tstring-rs/Cargo.toml

@@ -20,7 +20,7 @@ test = false
 saphyr = { workspace = true }
 saphyr-parser = { workspace = true }
 serde_json = { workspace = true }
-tstring-syntax = { version = "0.2.1", path = "../tstring-core-rs" }
+tstring-syntax = { version = "0.2.2", path = "../tstring-core-rs" }
 
 [dev-dependencies]
 toml = { workspace = true }

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/yaml-tstring-rs/src/lib.rs

@@ -3,11 +3,14 @@ use saphyr_parser::{ScalarStyle, Tag};
 use std::borrow::Cow;
 use std::str::FromStr;
 use tstring_syntax::{
-    BackendError, BackendResult, NormalizedDocument, NormalizedEntry, NormalizedFloat,
-    NormalizedKey, NormalizedKeyEntry, NormalizedStream, NormalizedValue, SourcePosition,
-    SourceSpan, StreamItem, TemplateInput,
+    BackendError, BackendResult, InterpolationTypeRequirement, NormalizedDocument, NormalizedEntry,
+    NormalizedFloat, NormalizedKey, NormalizedKeyEntry, NormalizedStream, NormalizedValue,
+    SourcePosition, SourceSpan, StreamItem, TemplateInput,
 };
 
+const YAML_VALUE_PYTHON_TYPE: &str = "str | int | float | bool | None | datetime.date | datetime.time | datetime.datetime | list[object] | dict[object, object]";
+const STRING_PYTHON_TYPE: &str = "str";
+
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum YamlProfile {
     V1_2_2,
@@ -2084,6 +2087,172 @@ pub fn check_template(template: &TemplateInput) -> BackendResult<()> {
     check_template_with_profile(template, YamlProfile::default())
 }
 
+pub fn interpolation_type_requirements_with_profile(
+    template: &TemplateInput,
+    profile: YamlProfile,
+) -> BackendResult<Vec<InterpolationTypeRequirement>> {
+    let stream = parse_validated_template_with_profile(template, profile)?;
+    let mut requirements = Vec::new();
+    collect_yaml_stream_type_requirements(&stream, &mut requirements);
+    requirements.sort_by_key(|requirement| requirement.interpolation_index);
+    Ok(requirements)
+}
+
+pub fn interpolation_type_requirements(
+    template: &TemplateInput,
+) -> BackendResult<Vec<InterpolationTypeRequirement>> {
+    interpolation_type_requirements_with_profile(template, YamlProfile::default())
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum YamlInterpolationContext {
+    Value,
+    MappingKey,
+}
+
+fn collect_yaml_stream_type_requirements(
+    stream: &YamlStreamNode,
+    requirements: &mut Vec<InterpolationTypeRequirement>,
+) {
+    for document in &stream.documents {
+        collect_yaml_value_type_requirements(
+            &document.value,
+            YamlInterpolationContext::Value,
+            requirements,
+        );
+    }
+}
+
+fn collect_yaml_value_type_requirements(
+    value: &YamlValueNode,
+    context: YamlInterpolationContext,
+    requirements: &mut Vec<InterpolationTypeRequirement>,
+) {
+    match value {
+        YamlValueNode::Scalar(node) => {
+            collect_yaml_scalar_type_requirements(node, "yaml scalar fragment", requirements);
+        }
+        YamlValueNode::Interpolation(node) => {
+            requirements.push(yaml_value_type_requirement(node, context));
+        }
+        YamlValueNode::Mapping(node) => {
+            for entry in &node.entries {
+                collect_yaml_key_type_requirements(&entry.key, requirements);
+                collect_yaml_value_type_requirements(
+                    &entry.value,
+                    YamlInterpolationContext::Value,
+                    requirements,
+                );
+            }
+        }
+        YamlValueNode::Sequence(node) => {
+            for item in &node.items {
+                collect_yaml_value_type_requirements(item, context, requirements);
+            }
+        }
+        YamlValueNode::Decorated(node) => {
+            if let Some(tag) = &node.tag {
+                collect_yaml_chunk_type_requirements(
+                    &tag.chunks,
+                    "yaml metadata fragment",
+                    requirements,
+                );
+            }
+            if let Some(anchor) = &node.anchor {
+                collect_yaml_chunk_type_requirements(
+                    &anchor.chunks,
+                    "yaml metadata fragment",
+                    requirements,
+                );
+            }
+            collect_yaml_value_type_requirements(&node.value, context, requirements);
+        }
+    }
+}
+
+fn collect_yaml_key_type_requirements(
+    key: &YamlKeyNode,
+    requirements: &mut Vec<InterpolationTypeRequirement>,
+) {
+    match &key.value {
+        YamlKeyValue::Scalar(node) => {
+            collect_yaml_scalar_type_requirements(node, "yaml scalar fragment", requirements);
+        }
+        YamlKeyValue::Interpolation(node) => {
+            requirements.push(yaml_value_type_requirement(
+                node,
+                YamlInterpolationContext::MappingKey,
+            ));
+        }
+        YamlKeyValue::Complex(node) => {
+            collect_yaml_value_type_requirements(
+                node,
+                YamlInterpolationContext::MappingKey,
+                requirements,
+            );
+        }
+    }
+}
+
+fn collect_yaml_scalar_type_requirements(
+    scalar: &YamlScalarNode,
+    description: &'static str,
+    requirements: &mut Vec<InterpolationTypeRequirement>,
+) {
+    match scalar {
+        YamlScalarNode::Plain(node) => {
+            collect_yaml_chunk_type_requirements(&node.chunks, description, requirements);
+        }
+        YamlScalarNode::DoubleQuoted(node) => {
+            collect_yaml_chunk_type_requirements(&node.chunks, description, requirements);
+        }
+        YamlScalarNode::SingleQuoted(node) => {
+            collect_yaml_chunk_type_requirements(&node.chunks, description, requirements);
+        }
+        YamlScalarNode::Block(node) => {
+            collect_yaml_chunk_type_requirements(&node.chunks, description, requirements);
+        }
+        YamlScalarNode::Alias(node) => {
+            collect_yaml_chunk_type_requirements(
+                &node.chunks,
+                "yaml metadata fragment",
+                requirements,
+            );
+        }
+    }
+}
+
+fn collect_yaml_chunk_type_requirements(
+    chunks: &[YamlChunk],
+    description: &'static str,
+    requirements: &mut Vec<InterpolationTypeRequirement>,
+) {
+    for chunk in chunks {
+        if let YamlChunk::Interpolation(node) = chunk {
+            requirements.push(InterpolationTypeRequirement::new(
+                node.interpolation_index,
+                STRING_PYTHON_TYPE,
+                description,
+            ));
+        }
+    }
+}
+
+fn yaml_value_type_requirement(
+    node: &YamlInterpolationNode,
+    context: YamlInterpolationContext,
+) -> InterpolationTypeRequirement {
+    let description = match context {
+        YamlInterpolationContext::Value => "yaml value",
+        YamlInterpolationContext::MappingKey => "yaml mapping key",
+    };
+    InterpolationTypeRequirement::new(
+        node.interpolation_index,
+        YAML_VALUE_PYTHON_TYPE,
+        description,
+    )
+}
+
 pub fn format_template_with_profile(
     template: &TemplateInput,
     profile: YamlProfile,

{tstring_bindings-0.2.1 → tstring_bindings-0.2.2}/yaml-tstring-rs/tests/parser.rs

@@ -1,6 +1,9 @@
-use tstring_syntax::{TemplateInput, TemplateInterpolation, TemplateSegment};
+use tstring_syntax::{
+    InterpolationTypeRequirement, TemplateInput, TemplateInterpolation, TemplateSegment,
+};
 use tstring_yaml::{
-    YamlValueNode, check_template, format_template, parse_template, validate_template,
+    YamlValueNode, check_template, format_template, interpolation_type_requirements,
+    parse_template, validate_template,
 };
 
 fn interpolation(index: usize, expression: &str) -> TemplateSegment {
@@ -129,6 +132,63 @@ fn validates_plain_scalars_with_multiple_interpolations_and_no_whitespace() {
     validate_template(&template).expect("expected YAML validation success");
 }
 
+#[test]
+fn reports_contextual_interpolation_type_requirements() {
+    let template = TemplateInput::from_segments(vec![
+        interpolation(0, "key"),
+        TemplateSegment::StaticText(": ".to_owned()),
+        interpolation(1, "value"),
+        TemplateSegment::StaticText("\nmessage: \"Hello ".to_owned()),
+        interpolation(2, "fragment"),
+        TemplateSegment::StaticText("\"\ntagged: !<tag:".to_owned()),
+        interpolation(3, "tag"),
+        TemplateSegment::StaticText("> ".to_owned()),
+        interpolation(4, "tagged_value"),
+        TemplateSegment::StaticText("\n".to_owned()),
+    ]);
+
+    assert_eq!(
+        interpolation_type_requirements(&template).expect("expected type requirements"),
+        vec![
+            InterpolationTypeRequirement::new(
+                0,
+                "str | int | float | bool | None | datetime.date | datetime.time | datetime.datetime | list[object] | dict[object, object]",
+                "yaml mapping key"
+            ),
+            InterpolationTypeRequirement::new(
+                1,
+                "str | int | float | bool | None | datetime.date | datetime.time | datetime.datetime | list[object] | dict[object, object]",
+                "yaml value"
+            ),
+            InterpolationTypeRequirement::new(2, "str", "yaml scalar fragment"),
+            InterpolationTypeRequirement::new(3, "str", "yaml metadata fragment"),
+            InterpolationTypeRequirement::new(
+                4,
+                "str | int | float | bool | None | datetime.date | datetime.time | datetime.datetime | list[object] | dict[object, object]",
+                "yaml value"
+            ),
+        ]
+    );
+}
+
+#[test]
+fn reports_complex_key_interpolation_requirements_in_key_context() {
+    let template = TemplateInput::from_segments(vec![
+        TemplateSegment::StaticText("? [".to_owned()),
+        interpolation(0, "item"),
+        TemplateSegment::StaticText("]\n: ok\n".to_owned()),
+    ]);
+
+    assert_eq!(
+        interpolation_type_requirements(&template).expect("expected type requirements"),
+        vec![InterpolationTypeRequirement::new(
+            0,
+            "str | int | float | bool | None | datetime.date | datetime.time | datetime.datetime | list[object] | dict[object, object]",
+            "yaml mapping key"
+        )]
+    );
+}
+
 #[test]
 fn formats_yaml_templates_with_raw_interpolations() {
     let template = TemplateInput::from_segments(vec![