linkml 1.9.5rc1__py3-none-any.whl → 1.9.5rc2__py3-none-any.whl

linkml/generators/rustgen/templates/as_key_value.rs.jinja

@@ -17,7 +17,9 @@ impl serde_utils::InlinedPair for {{ name }} {
             Value::Map(m) => m,
             _ => return Err("ClassDefinition must be a mapping".into()),
         };
-        map.insert(Value::String("{{key_property_name}}".into()), Value::String(k));
+        let key_value = serde_value::to_value(k.clone())
+            .map_err(|e| format!("unable to serialize key: {}", e))?;
+        map.insert(Value::String("{{key_property_name}}".into()), key_value);
         let de          = Value::Map(map).into_deserializer();
         match serde_path_to_error::deserialize(de) {
             Ok(ok)  => Ok(ok),
@@ -29,7 +31,9 @@ impl serde_utils::InlinedPair for {{ name }} {
 {% if can_convert_from_primitive %}
     fn from_pair_simple(k: Self::Key, v: Value) -> Result<Self,Self::Error> {
         let mut map:  BTreeMap<Value, Value> = BTreeMap::new();
-        map.insert(Value::String("{{ key_property_name }}".into()), Value::String(k));
+        let key_value = serde_value::to_value(k.clone())
+            .map_err(|e| format!("unable to serialize key: {}", e))?;
+        map.insert(Value::String("{{ key_property_name }}".into()), key_value);
         map.insert(Value::String("{{ value_property_name }}".into()), v);
         let de          = Value::Map(map).into_deserializer();
         match serde_path_to_error::deserialize(de) {
@@ -40,7 +44,9 @@ impl serde_utils::InlinedPair for {{ name }} {
 {% elif can_convert_from_empty %}
     fn from_pair_simple(k: Self::Key, _v: Value) -> Result<Self,Self::Error> {
         let mut map:  BTreeMap<Value, Value> = BTreeMap::new();
-        map.insert(Value::String("{{ key_property_name }}".into()), Value::String(k));
+        let key_value = serde_value::to_value(k.clone())
+            .map_err(|e| format!("unable to serialize key: {}", e))?;
+        map.insert(Value::String("{{ key_property_name }}".into()), key_value);
         let de          = Value::Map(map).into_deserializer();
         match serde_path_to_error::deserialize(de) {
             Ok(ok)  => Ok(ok),
@@ -53,4 +59,28 @@ impl serde_utils::InlinedPair for {{ name }} {
         Err("Cannot create a {{name}} from a primitive value!".into())
 {% endif %}
     }
+
+{% if can_convert_from_primitive %}
+    fn simple_value(&self) -> Option<&Self::Value> {
+{% if value_property_optional %}
+        self.{{ value_property_name }}.as_ref()
+{% else %}
+        Some(&self.{{ value_property_name }})
+{% endif %}
+    }
+{% endif %}
+
+    fn compact_value(&self) -> Option<Value> {
+        let value = match serde_value::to_value(self) {
+            Ok(v) => v,
+            Err(_) => return None,
+        };
+        match value {
+            Value::Map(mut map) => {
+                map.remove(&Value::String("{{ key_property_name }}".into()));
+                Some(Value::Map(map))
+            }
+            _ => None,
+        }
+    }
 }

linkml/generators/rustgen/templates/enum.rs.jinja

@@ -52,3 +52,19 @@ impl<'py> FromPyObject<'py> for {{ name }} {
         }
     }
 }
+
+#[cfg(feature = "stubgen")]
+impl ::pyo3_stub_gen::PyStubType for {{ name }} {
+    fn type_output() -> ::pyo3_stub_gen::TypeInfo {
+        {% set literal_values = items | map(attribute='text_literal') | list %}
+        {% set escaped_values = literal_values | map('replace', "'", "\\'" ) | list %}
+        {% if escaped_values %}
+        ::pyo3_stub_gen::TypeInfo::with_module(
+            "typing.Literal['{{ escaped_values | join("', '") }}']",
+            "typing".into(),
+        )
+        {% else %}
+        ::pyo3_stub_gen::TypeInfo::ident("typing.Any")
+        {% endif %}
+    }
+}

linkml/generators/rustgen/templates/file.rs.jinja

@@ -11,6 +11,10 @@ mod serde_utils;
 pub mod poly;
 pub mod poly_containers;
 {% endif %}
+{% if stubgen %}
+#[cfg(feature = "stubgen")]
+pub mod stub_utils;
+{% endif %}
 
 {{ imports }}
 
@@ -48,12 +52,21 @@ fn overwrite_except_none<T>(left: &mut Option<T>, right: Option<T>) {
 }
 {% endif %}
 
+{% if stubgen %}
+#[cfg(feature = "stubgen")]
+define_stub_info_gatherer!(stub_info);
+{% endif %}
+
 
 {% if pyo3 %}
 #[cfg(feature = "pyo3")]
+{% if handwritten_lib %}
+pub fn register_pymodule(m: &Bound<'_, PyModule>) -> PyResult<()> {
+{% else %}
 #[pymodule]
 #[pyo3(name="{{ name }}")]
 fn {{ name }}(m: &Bound<'_, PyModule>) -> PyResult<()> {
+{% endif %}
     {% for s in pyclass_struct_names %}
     m.add_class::<{{ s }}>()?;
     {% endfor %}

linkml/generators/rustgen/templates/lib_shim.rs.jinja

@@ -0,0 +1,52 @@
+//! This file will only be autogenerated once, so it is safe to manually edit (unlike the other generated files)
+//! If you want to re-generate it, just delete it and rerun rust generator.
+
+pub mod generated;
+
+pub use generated::*;
+pub use chrono::NaiveDate;
+pub use chrono::NaiveDateTime;
+
+{% if root_struct_name %}
+#[cfg(feature = "serde")]
+/// Example helper that loads a YAML document into the root class. Edit or extend as needed.
+pub fn load_yaml_{{ root_struct_fn_snake }}<P>(
+    path: P,
+) -> Result<generated::{{ root_struct_name }}, Box<dyn std::error::Error + Send + Sync>>
+where
+    P: AsRef<std::path::Path>,
+{
+    let file = std::fs::File::open(path)?;
+    let reader = std::io::BufReader::new(file);
+    let parsed = serde_yml::from_reader(reader)?;
+    Ok(parsed)
+}
+
+#[cfg(all(feature = "pyo3", feature = "serde"))]
+#[pyfunction(name = "load_yaml_{{ root_struct_fn_snake }}")]
+fn load_yaml_{{ root_struct_fn_snake }}_py(path: &str) -> PyResult<generated::{{ root_struct_name }}> {
+    load_yaml_{{ root_struct_fn_snake }}(path)
+        .map_err(|err| PyErr::new::<pyo3::exceptions::PyIOError, _>(err.to_string()))
+}
+{% endif %}
+
+{% if pyo3 %}
+#[cfg(feature = "pyo3")]
+use pyo3::prelude::*;
+#[cfg(all(feature = "pyo3", feature = "serde"))]
+use pyo3::wrap_pyfunction;
+
+#[cfg(feature = "pyo3")]
+#[pymodule]
+#[pyo3(name="{{ module_name }}")]
+fn {{ module_name }}(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    generated::register_pymodule(m)?;
+    {% if root_struct_name %}
+    #[cfg(all(feature = "serde", feature = "pyo3"))]
+    {
+        m.add_function(wrap_pyfunction!(load_yaml_{{ root_struct_fn_snake }}_py, m)?)?;
+    }
+    {% endif %}
+    Ok(())
+}
+{% endif %}

linkml/generators/rustgen/templates/poly_trait_property_impl.rs.jinja

@@ -118,7 +118,9 @@
         return Some(&self.{{ name }});
         {% endif %}
 {% else %}
-        {% if is_copy %}
+        {% if ct == 'list' or ct == 'mapping' %}
+        return &self.{{ name }};
+        {% elif is_copy %}
         return self.{{ name }};
         {% elif type_getter == "&'a str" or type_getter == "&str" %}
         return &self.{{ name }}[..];

linkml/generators/rustgen/templates/property.rs.jinja

@@ -3,12 +3,21 @@
 {% endif %}
 {%- if is_key_value -%}
 {% if container_mode == "list" and inline_mode == "inline" %}
-#[cfg_attr(feature = "serde", serde(deserialize_with = "serde_utils::deserialize_inlined_dict_list{% if optional %}_optional{% endif %}{% if recursive %}_box{% endif %}"))]
+#[cfg_attr(feature = "serde", serde(
+    deserialize_with = "serde_utils::deserialize_inlined_dict_list{% if optional %}_optional{% endif %}{% if recursive %}_box{% endif %}",
+    serialize_with = "serde_utils::serialize_inlined_dict_list{% if optional %}_optional{% endif %}"
+))]
 {% elif container_mode == "mapping" and inline_mode == "inline" %}
-#[cfg_attr(feature = "serde", serde(deserialize_with = "serde_utils::deserialize_inlined_dict_map{% if optional %}_optional{% endif %}{% if recursive %}_box{% endif %}"))]
+#[cfg_attr(feature = "serde", serde(
+    deserialize_with = "serde_utils::deserialize_inlined_dict_map{% if optional %}_optional{% endif %}{% if recursive %}_box{% endif %}",
+    serialize_with = "serde_utils::serialize_inlined_dict_map{% if optional %}_optional{% endif %}"
+))]
 {% endif %}
 {% elif container_mode == "list" and inline_mode == "primitive" %}
-#[cfg_attr(feature = "serde", serde(deserialize_with = "serde_utils::deserialize_primitive_list_or_single_value{% if optional %}_optional{% endif %}"))]
+#[cfg_attr(feature = "serde", serde(
+    deserialize_with = "serde_utils::deserialize_primitive_list_or_single_value{% if optional %}_optional{% endif %}",
+    serialize_with = "serde_utils::serialize_primitive_list_or_single_value{% if optional %}_optional{% endif %}"
+))]
 {% endif -%}
 {% if hasdefault %}
 #[cfg_attr(feature = "serde", serde(default))]

linkml/generators/rustgen/templates/serde_utils.rs.jinja

@@ -1,9 +1,15 @@
 #[cfg(feature = "serde")]
-use serde::{de::{DeserializeOwned, IntoDeserializer}, Deserialize, Deserializer};
+use serde::{
+    de::{DeserializeOwned, IntoDeserializer},
+    Deserialize,
+    Deserializer,
+    Serialize,
+    Serializer,
+};
 #[cfg(feature = "serde")]
 use serde::de::Error;
 #[cfg(feature = "serde")]
-use serde_value::{Value, ValueDeserializer};
+use serde_value::{to_value, Value, ValueDeserializer};
 #[cfg(feature = "serde")]
 use std::collections::{BTreeMap, HashMap};
 #[cfg(all(feature = "serde", feature = "pyo3"))]
@@ -20,6 +26,14 @@ pub trait InlinedPair: Sized {
     fn from_pair_mapping(k: Self::Key, v: Value) -> Result<Self,Self::Error>;
     fn from_pair_simple(k: Self::Key, v: Value) -> Result<Self,Self::Error>;
     fn extract_key(&self) -> &Self::Key;
+
+    fn simple_value(&self) -> Option<&Self::Value> {
+        None
+    }
+
+    fn compact_value(&self) -> Option<Value> {
+        None
+    }
 }
 
 #[cfg(feature = "serde")]
@@ -46,6 +60,14 @@ where
         T::extract_key(self)
      }
 
+    fn simple_value(&self) -> Option<&Self::Value> {
+        self.as_ref().simple_value()
+    }
+
+    fn compact_value(&self) -> Option<Value> {
+        self.as_ref().compact_value()
+    }
+
 }
 
 #[cfg(feature = "serde")]
@@ -176,8 +198,12 @@ where
 }
 
 pub fn deserialize_primitive_list_or_single_value<'de, D, T>(
-    deserializer:  D
-) -> Result<Vec<T>, D::Error> where D: Deserializer<'de>, T: Deserialize<'de> {
+    deserializer: D
+) -> Result<Vec<T>, D::Error>
+where
+    D: Deserializer<'de>,
+    T: Deserialize<'de>,
+{
     let ast: Value = Value::deserialize(deserializer)?;
     match ast {
         Value::Seq(seq) => {
@@ -197,8 +223,12 @@ pub fn deserialize_primitive_list_or_single_value<'de, D, T>(
 
 
 pub fn deserialize_primitive_list_or_single_value_optional<'de, D, T>(
-    deserializer:  D
-) -> Result<Option<Vec<T>>, D::Error> where D: Deserializer<'de>, T: Deserialize<'de> {
+    deserializer: D
+) -> Result<Option<Vec<T>>, D::Error>
+where
+    D: Deserializer<'de>,
+    T: Deserialize<'de>,
+{
     let ast: Value = Value::deserialize(deserializer)?;
     match ast {
         Value::Unit => Ok(None),
@@ -274,6 +304,146 @@ fn py_any_to_value(bound: &Bound<'_, PyAny>) -> PyResult<Value> {
     ))
 }
 
+#[cfg(feature = "serde")]
+#[allow(dead_code)]
+pub fn serialize_inlined_dict_map<S, T>(
+    value: &HashMap<T::Key, T>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: InlinedPair + Serialize,
+    T::Key: Serialize + Clone + Ord,
+    T::Value: Serialize,
+{
+    let mut ordered: BTreeMap<T::Key, &T> = BTreeMap::new();
+    for (k, v) in value.iter() {
+        ordered.insert(k.clone(), v);
+    }
+
+    let mut as_values: BTreeMap<T::Key, Value> = BTreeMap::new();
+    for (k, v) in ordered.iter() {
+        if let Some(simple) = v.simple_value() {
+            let val = to_value(simple)
+                .map_err(|e| <S::Error as serde::ser::Error>::custom(e))?;
+            as_values.insert((*k).clone(), val);
+            continue;
+        }
+        if let Some(compact) = v.compact_value() {
+            as_values.insert((*k).clone(), compact);
+            continue;
+        }
+        let val = to_value(*v)
+            .map_err(|e| <S::Error as serde::ser::Error>::custom(e))?;
+        as_values.insert((*k).clone(), val);
+    }
+    as_values.serialize(serializer)
+}
+
+#[cfg(feature = "serde")]
+#[allow(dead_code)]
+pub fn serialize_inlined_dict_map_optional<S, T>(
+    value: &Option<HashMap<T::Key, T>>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: InlinedPair + Serialize,
+    T::Key: Serialize + Clone + Ord,
+    T::Value: Serialize,
+{
+    match value {
+        Some(map) => serialize_inlined_dict_map(map, serializer),
+        None => serializer.serialize_none(),
+    }
+}
+
+#[cfg(feature = "serde")]
+#[allow(dead_code)]
+pub fn serialize_inlined_dict_list<S, T>(
+    value: &Vec<T>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: InlinedPair + Serialize,
+    T::Key: Serialize + Clone + Ord,
+    T::Value: Serialize,
+{
+    let mut ordered: BTreeMap<T::Key, &T> = BTreeMap::new();
+    for item in value.iter() {
+        ordered.insert(item.extract_key().clone(), item);
+    }
+
+    let mut as_values: BTreeMap<T::Key, Value> = BTreeMap::new();
+    for (k, v) in ordered.iter() {
+        if let Some(simple) = v.simple_value() {
+            let val = to_value(simple)
+                .map_err(|e| <S::Error as serde::ser::Error>::custom(e))?;
+            as_values.insert((*k).clone(), val);
+            continue;
+        }
+        if let Some(compact) = v.compact_value() {
+            as_values.insert((*k).clone(), compact);
+            continue;
+        }
+        let val = to_value(*v)
+            .map_err(|e| <S::Error as serde::ser::Error>::custom(e))?;
+        as_values.insert((*k).clone(), val);
+    }
+    as_values.serialize(serializer)
+}
+
+#[cfg(feature = "serde")]
+#[allow(dead_code)]
+pub fn serialize_inlined_dict_list_optional<S, T>(
+    value: &Option<Vec<T>>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: InlinedPair + Serialize,
+    T::Key: Serialize + Clone + Ord,
+    T::Value: Serialize,
+{
+    match value {
+        Some(items) => serialize_inlined_dict_list(items, serializer),
+        None => serializer.serialize_none(),
+    }
+}
+
+#[cfg(feature = "serde")]
+#[allow(dead_code)]
+pub fn serialize_primitive_list_or_single_value<S, T>(
+    value: &Vec<T>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: Serialize,
+{
+    match value.as_slice() {
+        [single] => single.serialize(serializer),
+        _ => value.serialize(serializer),
+    }
+}
+
+#[cfg(feature = "serde")]
+#[allow(dead_code)]
+pub fn serialize_primitive_list_or_single_value_optional<S, T>(
+    value: &Option<Vec<T>>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: Serialize,
+{
+    match value {
+        Some(v) => serialize_primitive_list_or_single_value(v, serializer),
+        None => serializer.serialize_none(),
+    }
+}
+
 #[cfg(all(feature = "serde", feature = "pyo3"))]
 pub fn deserialize_py_any<'py, T>(bound: &Bound<'py, PyAny>) -> PyResult<T>
 where
@@ -299,6 +469,16 @@ impl<T> PyValue<T> {
     }
 }
 
+#[cfg(all(feature = "pyo3", feature = "stubgen"))]
+impl<T> ::pyo3_stub_gen::PyStubType for PyValue<T>
+where
+    T: ::pyo3_stub_gen::PyStubType,
+{
+    fn type_output() -> ::pyo3_stub_gen::TypeInfo {
+        T::type_output()
+    }
+}
+
 #[cfg(all(feature = "pyo3", feature = "serde"))]
 impl<'py, T> FromPyObject<'py> for PyValue<T>
 where

linkml/generators/rustgen/templates/slot_range_as_union.rs.jinja

@@ -59,3 +59,6 @@
             ))
         }
     }
+
+    #[cfg(feature = "stubgen")]
+    ::pyo3_stub_gen::impl_stub_type!({{ slot_name }}_range = {{ ranges | join(' | ') }});

linkml/generators/rustgen/templates/struct.rs.jinja

@@ -8,6 +8,9 @@ pub type AnyValue = Anything;
 {% endif %}
 #[derive(Debug, Clone, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+{% if stubgen %}
+#[cfg_attr(feature = "stubgen", gen_stub_pyclass)]
+{% endif %}
 #[cfg_attr(feature = "pyo3", pyclass(subclass, get_all, set_all))]
 {% if generate_merge %}
 #[derive(Merge)]
@@ -22,6 +25,9 @@ pub struct {{ name }} {
 }
 {% if properties | length > 0 %}
 #[cfg(feature = "pyo3")]
+{% if stubgen %}
+#[cfg_attr(feature = "stubgen", gen_stub_pymethods)]
+{% endif %}
 #[pymethods]
 impl {{ name }} {
     #[new]

linkml/generators/rustgen/templates/struct_or_subtype_enum.rs.jinja

@@ -75,7 +75,7 @@ impl<'py> FromPyObject<'py> for Box<{{ enum_name }}> {
 {% if as_key_value %}
 #[cfg(feature = "serde")]
 impl serde_utils::InlinedPair for {{enum_name}} {
-    type Key       = String;
+    type Key       = {{ key_property_type }};
     type Value     = serde_value::Value;
     type Error     = String;
 
@@ -106,3 +106,6 @@ impl serde_utils::InlinedPair for {{enum_name}} {
     }
 }
 {% endif %}
+
+#[cfg(feature = "stubgen")]
+::pyo3_stub_gen::impl_stub_type!({{ enum_name }} = {{ struct_names | join(' | ') }});

linkml/generators/rustgen/templates/stub_gen.rs.jinja

@@ -0,0 +1,71 @@
+#[cfg(feature = "stubgen")]
+use {{ crate_module }}::stub_utils;
+
+#[cfg(feature = "stubgen")]
+fn main() -> pyo3_stub_gen::Result<()> {
+    let check_only = std::env::args().skip(1).any(|arg| arg == "--check");
+    let stub = {{ crate_name }}::stub_info()?;
+
+    if check_only {
+        check_stubs(&stub)
+    } else {
+        stub.generate()
+    }
+}
+
+#[cfg(feature = "stubgen")]
+fn check_stubs(stub: &pyo3_stub_gen::StubInfo) -> pyo3_stub_gen::Result<()> {
+    use std::fs;
+    use std::io::ErrorKind;
+
+    let mut issues = Vec::new();
+
+    for (name, module) in &stub.modules {
+        let module_path = stub_utils::normalize_stub_module(name)?;
+        let mut dest = stub.python_root.join(&module_path);
+        if module.submodules.is_empty() {
+            dest.set_extension("pyi");
+        } else {
+            dest.push("__init__.pyi");
+        }
+
+        let expected = module.to_string();
+        match fs::read_to_string(&dest) {
+            Ok(actual) => {
+                if actual != expected {
+                    issues.push(format!(
+                        "updated content differs for `{}` (module `{name}`)",
+                        dest.display()
+                    ));
+                }
+            }
+            Err(err) if err.kind() == ErrorKind::NotFound => {
+                issues.push(format!(
+                    "missing stub file `{}` for module `{name}`",
+                    dest.display()
+                ));
+            }
+            Err(err) => return Err(err.into()),
+        }
+    }
+
+    if issues.is_empty() {
+        Ok(())
+    } else {
+        let mut msg = String::from("Stub files are out of date:\n");
+        for issue in issues {
+            msg.push_str("  - ");
+            msg.push_str(&issue);
+            msg.push('\n');
+        }
+        msg.push_str("Run `cargo run --bin stub_gen --features stubgen` to regenerate.");
+        Err(std::io::Error::new(ErrorKind::Other, msg).into())
+    }
+}
+
+#[cfg(not(feature = "stubgen"))]
+fn main() {
+    eprintln!(
+        "Enable the `stubgen` feature (alongside `pyo3`) to run this generator."
+    );
+}

linkml/generators/rustgen/templates/stub_utils.rs.jinja

@@ -0,0 +1,76 @@
+use std::io::{Error, ErrorKind};
+use std::path::{Component, PathBuf};
+
+/// Convert a stub module name into a relative filesystem path.
+///
+/// The generator currently expects module names that mirror Python package
+/// semantics (``foo.bar``) with optional hyphens. Hyphens are replaced with
+/// underscores and dots map to directory separators. The helper rejects
+/// absolute paths, traversal markers, or characters that cannot appear in
+/// stub files so we never escape the designated stub root.
+pub fn normalize_stub_module(name: &str) -> std::io::Result<PathBuf> {
+    if name.is_empty() {
+        return Err(Error::new(
+            ErrorKind::InvalidInput,
+            "module name may not be empty",
+        ));
+    }
+
+    let normalized = name.replace('-', "_");
+    let path_str = normalized.replace('.', "/");
+    let path = PathBuf::from(&path_str);
+
+    if path.is_absolute() {
+        return Err(Error::new(
+            ErrorKind::InvalidInput,
+            format!("absolute module path `{name}` not allowed"),
+        ));
+    }
+
+    for component in path.components() {
+        match component {
+            Component::Normal(part) => {
+                let segment = part.to_string_lossy();
+                if segment.is_empty() {
+                    return Err(Error::new(
+                        ErrorKind::InvalidInput,
+                        format!("module name `{name}` contains an empty segment"),
+                    ));
+                }
+                if segment == "." || segment == ".." {
+                    return Err(Error::new(
+                        ErrorKind::InvalidInput,
+                        format!(
+                            "module name `{name}` contains disallowed segment `{segment}`"
+                        ),
+                    ));
+                }
+                if segment
+                    .chars()
+                    .any(|ch| matches!(ch, '*' | '?' | '<' | '>' | '|' | ':' | '\\' | '/'))
+                {
+                    return Err(Error::new(
+                        ErrorKind::InvalidInput,
+                        format!(
+                            "module name `{name}` contains invalid characters in `{segment}`"
+                        ),
+                    ));
+                }
+            }
+            Component::CurDir | Component::ParentDir => {
+                return Err(Error::new(
+                    ErrorKind::InvalidInput,
+                    format!("module name `{name}` attempts directory traversal"),
+                ));
+            }
+            Component::RootDir | Component::Prefix(_) => {
+                return Err(Error::new(
+                    ErrorKind::InvalidInput,
+                    format!("module name `{name}` resolves outside stub root"),
+                ));
+            }
+        }
+    }
+
+    Ok(path)
+}

linkml/generators/yarrrmlgen.py

@@ -32,7 +32,18 @@ class YarrrmlGenerator(Generator):
     visit_all_class_slots = False
 
     def __init__(self, schema: str | TextIO | SchemaDefinition, format: str = "yml", **kwargs):
-        src = kwargs.pop("source", None)
+        def _infer_source_suffix(path: str) -> str:
+            p = (path or "").lower()
+            if "~" in p:
+                return path  # already has ~jsonpath or ~csv
+            if p.endswith(".json"):
+                return f"{path}~jsonpath"
+            if p.endswith(".csv") or p.endswith(".tsv"):
+                return f"{path}~csv"
+            return path
+
+        # in __init__ right after you read src:
+        raw_src = kwargs.pop("source", None)
         it = kwargs.pop("iterator_template", None)
 
         super().__init__(schema, **kwargs)
@@ -42,7 +53,12 @@ class YarrrmlGenerator(Generator):
 
         self.format = format
 
-        self.source: str = src or DEFAULT_SOURCE_JSON
+        # normalize source: if user passed file without "~csv/~jsonpath", infer it
+        if raw_src:
+            self.source = _infer_source_suffix(raw_src)
+        else:
+            self.source = DEFAULT_SOURCE_JSON
+
         self.iterator_template: str = it or DEFAULT_ITERATOR
 
     # public
@@ -70,7 +86,7 @@ class YarrrmlGenerator(Generator):
             if self._is_json_source():
                 mapping["sources"] = [[self.source, self._iterator_for_class(cls)]]
             else:
-                mapping["sources"] = [self.source]
+                mapping["sources"] = [[self.source]]
 
             mappings[str(cls.name)] = mapping
 
@@ -136,7 +152,7 @@ class YarrrmlGenerator(Generator):
 @click.command(name="yarrrml")
 @click.option(
     "--source",
-    help="YARRRML source shorthand, e.g., data.json~jsonpath or data.csv~csv",
+    help="YARRRML source shorthand, e.g., data.json~jsonpath or data.csv~csv (TSV works too)",
 )
 @click.option(
     "--iterator-template",