linkml 1.9.4rc1__py3-none-any.whl → 1.9.5__py3-none-any.whl

linkml/generators/rustgen/templates/Cargo.toml.jinja

@@ -0,0 +1,42 @@
+[package]
+name = "{{ name }}"
+version = "{{ version }}"
+edition = "{{ edition }}"
+
+[lib]
+name = "{{ name }}"
+{% if pyo3 %}
+crate-type = ["cdylib", "rlib"]
+{% else %}
+crate-type = ["lib"]
+{% endif %}
+
+[dependencies]
+{% for i in imports %}
+    {% if i.version %}
+        {% if i.features %}
+{{ i.module }} = { version = "{{ i.version }}", features = [{% for feature in i.features %}"{{ feature }}"{% if not loop.last %},{% endif %}{% endfor %}] {% if i.feature_flag %} , optional = true {% endif %} }
+        {% else %}
+            {% if i.feature_flag %}
+{{ i.module }} = { version = "{{ i.version }}", optional = true }
+            {% else %}
+{{ i.module }} = "{{ i.version }}"
+            {% endif %}
+        {% endif %}
+    {% endif %}
+{% endfor %}
+
+
+[features]
+{% if pyo3 and serde %}
+default = ["pyo3", "serde"]
+{% elif pyo3 %}
+default = ["pyo3"]
+{% elif serde %}
+default = ["serde"]
+{% else %}
+default = []
+{% endif %}
+{% for k,v in cratefeatures.items() %}
+{{ k }} = [{% for i in v %}"{{ i }}"{% if not loop.last %}, {% endif %}{% endfor %}]
+{% endfor %}

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

@@ -0,0 +1,149 @@
+#[derive(Clone, PartialEq)]
+pub struct Anything(
+    #[cfg(feature = "serde")] pub serde_value::Value,
+    #[cfg(not(feature = "serde"))] pub (),
+);
+
+
+#[cfg(feature = "stubgen")]
+impl ::pyo3_stub_gen::PyStubType for Anything {
+    fn type_output() -> ::pyo3_stub_gen::TypeInfo {
+        ::pyo3_stub_gen::TypeInfo::any()
+    }
+}
+
+
+#[cfg(feature = "serde")]
+impl Serialize for Anything {
+    fn serialize<S>(&self, to_ser: S) -> Result<S::Ok, S::Error>
+    where S: serde::Serializer {
+        self.0.serialize(to_ser)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Anything {
+    fn deserialize<D>(de: D) -> Result<Self, D::Error>
+    where D: serde::Deserializer<'de> {
+        <serde_value::Value as Deserialize>::deserialize(de).map(Anything)
+    }
+}
+
+#[cfg(all(feature = "pyo3", feature = "serde"))]
+impl<'py> FromPyObject<'py> for Anything {
+    fn extract_bound(obj: &pyo3::Bound<'py, pyo3::types::PyAny>) -> pyo3::PyResult<Self> {
+        use pyo3::types::{PyAny, PyDict, PyList, PyTuple};
+        use serde_value::Value;
+
+        fn py_to_value<'py>(o: &pyo3::Bound<'py, PyAny>) -> pyo3::PyResult<Value> {
+            // None -> Unit
+            if o.is_none() {
+                return Ok(Value::Unit);
+            }
+
+            // Try simple primitives first
+            if let Ok(s) = o.extract::<&str>() {
+                return Ok(Value::String(s.to_string()));
+            }
+            if let Ok(b) = o.extract::<bool>() {
+                return Ok(Value::Bool(b));
+            }
+
+            // Sequences (list/tuple)
+            if let Ok(list) = o.downcast::<PyList>() {
+                let mut out = Vec::with_capacity(list.len());
+                for item in list.iter() {
+                    out.push(py_to_value(&item)?);
+                }
+                return Ok(Value::Seq(out));
+            }
+            if let Ok(t) = o.downcast::<PyTuple>() {
+                let mut out = Vec::with_capacity(t.len());
+                for item in t.iter() {
+                    out.push(py_to_value(&item)?);
+                }
+                return Ok(Value::Seq(out));
+            }
+
+            // Mappings (dict with string-like keys)
+            if let Ok(d) = o.downcast::<PyDict>() {
+                let mut map = std::collections::BTreeMap::<Value, Value>::new();
+                for (k, v) in d.iter() {
+                    // Only accept string-like keys for deterministic ordering
+                    if let Ok(ks) = k.extract::<&str>() {
+                        map.insert(Value::String(ks.to_string()), py_to_value(&v)?);
+                    } else {
+                        return Err(pyo3::exceptions::PyTypeError::new_err(
+                            "dict keys for Anything must be str",
+                        ));
+                    }
+                }
+                return Ok(Value::Map(map));
+            }
+
+            // Fallback: stringify unknown types
+            let s = format!("{}", o.str()?);
+            Ok(Value::String(s))
+        }
+
+        Ok(Anything(py_to_value(obj)?))
+    }
+}
+
+/* ---------- getter side ---------- */
+#[cfg(all(feature = "pyo3", feature = "serde"))]
+impl<'py> IntoPyObject<'py> for Anything {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        use pyo3::types::{PyAny, PyDict, PyList, PyString};
+        use serde_value::Value;
+
+        fn value_to_py<'py>(py: Python<'py>, v: &Value) -> pyo3::PyResult<Bound<'py, PyAny>> {
+            match v {
+                Value::Unit => Ok(py.None().into_bound(py)),
+                Value::Bool(b) => Ok(pyo3::types::PyBool::new(py, *b).to_owned().into_any()),
+                Value::String(s) => Ok(PyString::new(py, s).into_any()),
+                Value::Seq(seq) => {
+                    let list = PyList::empty(py);
+                    for item in seq.iter() {
+                        let ob = value_to_py(py, item)?;
+                        list.append(ob)?;
+                    }
+                    Ok(list.into_any())
+                }
+                Value::Map(map) => {
+                    let dict = PyDict::new(py);
+                    for (k, v) in map.iter() {
+                        let pk = value_to_py(py, k)?;
+                        let pv = value_to_py(py, v)?;
+                        dict.set_item(pk, pv)?;
+                    }
+                    Ok(dict.into_any())
+                }
+                // Best-effort for other serde_value variants
+                // (numbers, bytes, chars, etc.)
+                other => {
+                    // Try common cases without bringing extra deps
+                    // Numbers are converted via string if not covered above
+                    let s = format!("{:?}", other);
+                    Ok(PyString::new(py, &s).into_any())
+                }
+            }
+        }
+
+        value_to_py(py, &self.0)
+    }
+}
+
+impl std::fmt::Debug for Anything {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        #[cfg(feature = "serde")]
+        return write!(f, "Anything({:?})", self.0);
+
+        #[cfg(not(feature = "serde"))]
+        return f.write_str("Anything(<opaque>)");
+    }
+}

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

@@ -0,0 +1,86 @@
+#[cfg(feature = "serde")]
+impl serde_utils::InlinedPair for {{ name }} {
+    type Key   = {{ key_property_type }};
+{% if can_convert_from_primitive %}
+    type Value = {{ value_property_type }};
+{% else %}
+    type Value = Value;
+{% endif %}
+    type Error = String;
+
+    fn extract_key(&self) -> &Self::Key {
+        return &self.{{ key_property_name }};
+    }
+
+    fn from_pair_mapping(k: Self::Key, v: Value) -> Result<Self,Self::Error> {
+        let mut map = match v {
+            Value::Map(m) => m,
+            _ => return Err("ClassDefinition must be a mapping".into()),
+        };
+        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),
+            Err(e)  => Err(format!("at `{}`: {}", e.path(), e.inner())),
+        }
+    }
+
+
+{% 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();
+        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) {
+            Ok(ok)  => Ok(ok),
+            Err(e)  => Err(format!("at `{}`: {}", e.path(), e.inner())),
+        }
+
+{% 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();
+        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),
+            Err(e)  => Err(format!("at `{}`: {}", e.path(), e.inner())),
+        }
+
+
+{% else %}
+    fn from_pair_simple(_k: Self::Key, _v: Value) -> Result<Self,Self::Error> {
+        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/class_module.rs.jinja

@@ -0,0 +1,8 @@
+{% if slot_ranges | length > 0%}
+pub mod {{ class_name_snakecase }}_utl {
+    use super::*;
+{% for u in slot_ranges %}
+{{ u}}
+{% endfor %}
+}
+{% endif %}

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

@@ -0,0 +1,70 @@
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum {{ name }} {
+{% for item in items %}
+    {% if serde %}#[cfg_attr(feature = "serde", serde(rename = "{{ item.text_literal }}"))]
+    {% endif %}
+    {{ item.variant }},
+{% endfor %}
+}
+
+impl core::fmt::Display for {{ name }} {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+        {% for item in items %}
+            {{ name }}::{{ item.variant }} => f.write_str("{{ item.text_literal }}"),
+        {% endfor %}
+        }
+    }
+}
+
+#[cfg(feature = "pyo3")]
+impl<'py> IntoPyObject<'py> for {{ name }} {
+    type Target = PyAny;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let s: &str = match self {
+        {% for item in items %}
+            {{ name }}::{{ item.variant }} => "{{ item.text_literal }}",
+        {% endfor %}
+        };
+        Ok(pyo3::types::PyString::new(py, s).into_any())
+    }
+}
+
+#[cfg(feature = "pyo3")]
+impl<'py> FromPyObject<'py> for {{ name }} {
+    fn extract_bound(ob: &pyo3::Bound<'py, pyo3::types::PyAny>) -> pyo3::PyResult<Self> {
+        if let Ok(s) = ob.extract::<&str>() {
+            match s {
+            {% for item in items %}
+                {{ item.python_match_pattern }} => Ok({{ name }}::{{ item.variant }}),
+            {% endfor %}
+                _ => Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+                    format!("invalid value for {{ name }}: {}", s),
+                )),
+            }
+        } else {
+            Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
+                concat!("expected str for ", stringify!({{ 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

@@ -0,0 +1,75 @@
+#![allow(non_camel_case_types)]
+
+{% if inline_serde_utils %}
+#[cfg(feature = "serde")]
+mod serde_utils { {{ serde_utils }} }
+{% else %}
+#[cfg(feature = "serde")]
+mod serde_utils;
+{% endif %}
+{% if emit_poly %}
+pub mod poly;
+pub mod poly_containers;
+{% endif %}
+{% if stubgen %}
+#[cfg(feature = "stubgen")]
+pub mod stub_utils;
+{% endif %}
+
+{{ imports }}
+
+// Types
+
+{% for type in types %}
+{{ type }}
+{% endfor %}
+
+// Slots
+
+{% for slot in slots %}
+{{ slot }}
+{% endfor %}
+
+// Enums
+
+{% for enum in enums %}
+{{ enum }}
+{% endfor %}
+
+// Classes
+
+{% for struct in structs %}
+{{ struct }}
+{% endfor %}
+
+
+{% if needs_overwrite_except_none %}
+/// Overwrite `left` with `right` unless `right` is `None`.
+fn overwrite_except_none<T>(left: &mut Option<T>, right: Option<T>) {
+    if right.is_some() {
+        *left = right;
+    }
+}
+{% 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 %}
+    Ok(())
+}
+{% endif %}

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

@@ -0,0 +1,4 @@
+{% if feature_flag %}
+#[cfg(feature = "{{ feature_flag }}")]
+{% endif %}
+use {{ module.replace('-','_') }}{% if objects %}::{{ "{" if objects|length > 1 else "" }}{% for obj in objects %}{{ obj.name }}{% if obj.alias %} as {{ obj.alias}}{% endif %}{% if not loop.last %},{% endif %}{% endfor %}{{ "}" if objects|length > 1 else "" }}{% else %}{% if alias %} as {{ alias }} {% endif %}{% endif %};

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

@@ -0,0 +1,8 @@
+{% if imports is string %}
+{{ imports }}
+{% else %}
+    {% for import in imports %}
+{{ import }}
+    {% endfor %}
+{% endif %}
+use std::collections::BTreeMap;

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.rs.jinja

@@ -0,0 +1,9 @@
+#![allow(non_camel_case_types)]
+
+use crate::*;
+use crate::poly_containers::*;
+
+
+{% for t in traits %}
+{{ t }}
+{% endfor %}