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

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

@@ -0,0 +1,111 @@
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+{% if type_designator_field %}
+#[cfg_attr(feature="serde", serde(tag = "{{ type_designator_field }}"))]
+{% else %}
+#[cfg_attr(feature="serde", serde(untagged))]
+{% endif %}
+pub enum {{ enum_name }} {
+{%- for t in struct_names -%}
+    {% if type_designator_field  %}
+    {% set tds = type_designators[t] %}
+    #[serde(rename = "{{ tds[0] }}",  {% for t in tds[1:] %} alias="{{ t }}", {% endfor %} )]
+    {% endif %}
+    {{ t }}({{ t }}){% if not loop.last %}, {% endif %}
+{%- endfor -%}
+}
+
+{% for t in struct_names %}
+impl From<{{ t }}>   for {{ enum_name }} { fn from(x: {{ t }})   -> Self { Self::{{ t }}(x) } }
+{% endfor %}
+
+#[cfg(feature = "pyo3")]
+impl<'py> FromPyObject<'py> for {{ enum_name }} {
+    fn extract_bound(ob: &pyo3::Bound<'py, pyo3::types::PyAny>) -> pyo3::PyResult<Self> {
+{% for t in struct_names %}
+        if let Ok(val) = ob.extract::<{{ t }}>() {
+            return Ok({{ enum_name }}::{{ t }}(val));
+        }
+{%- endfor -%}
+        Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
+            "invalid {{ enum_name }}",
+        ))
+    }
+}
+
+#[cfg(feature = "pyo3")]
+impl<'py> IntoPyObject<'py> for {{ enum_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> {
+        match self {
+{% for t in struct_names %}
+            {{ enum_name }}::{{ t }}(val) => val.into_pyobject(py).map(move |b| b.into_any()),
+{% endfor %}
+        }
+    }
+}
+
+
+#[cfg(feature = "pyo3")]
+impl<'py> IntoPyObject<'py> for Box<{{ enum_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> {
+        (*self).into_pyobject(py).map(move |x| x.into_any())
+    }
+}
+
+#[cfg(feature = "pyo3")]
+impl<'py> FromPyObject<'py> for Box<{{ enum_name }}> {
+    fn extract_bound(ob: &pyo3::Bound<'py, pyo3::types::PyAny>) -> pyo3::PyResult<Self> {
+        if let Ok(val) = ob.extract::<{{ enum_name }}>() {
+            return Ok(Box::new(val));
+        }
+        Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
+            "invalid {{ enum_name }}",
+        ))
+    }
+}
+
+{% if as_key_value %}
+#[cfg(feature = "serde")]
+impl serde_utils::InlinedPair for {{enum_name}} {
+    type Key       = {{ key_property_type }};
+    type Value     = serde_value::Value;
+    type Error     = String;
+
+    fn from_pair_mapping(k: Self::Key, v: Self::Value) -> Result<Self, Self::Error> {
+        {% for t in struct_names %}
+        if let Ok(x) = {{t}}::from_pair_mapping(k.clone(), v.clone()) {
+            return Ok({{enum_name}}::{{t}}(x));
+        }
+        {% endfor %}
+        Err("none of the variants matched the mapping form".into())
+    }
+
+    fn from_pair_simple(k: Self::Key, v: Self::Value) -> Result<Self, Self::Error> {
+        {% for t in struct_names %}
+        if let Ok(x) = {{t}}::from_pair_simple(k.clone(), v.clone()) {
+            return Ok({{enum_name}}::{{t}}(x));
+        }
+        {% endfor %}
+        Err("none of the variants support the primitive form".into())
+    }
+
+    fn extract_key(&self) -> &Self::Key {
+        match self {
+        {% for t in struct_names %}
+            {{enum_name}}::{{t}}(inner) => inner.extract_key(),
+        {% endfor %}
+        }
+    }
+}
+{% 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/rustgen/templates/typealias.rs.jinja

@@ -0,0 +1,13 @@
+{% if attributes or description %}
+#[
+{%- if description -%}doc = r" {{ description | escape }}", {%- endif -%}
+{%- for key, val in attributes.items() -%}
+{{ key }} = "{{ val }}"{% if not loop.last %}, {% endif %}
+{%- endfor -%}
+]
+{%- endif -%}
+pub type {{ name }} = {%- if multivalued %} Vec<{{ type_ }}>
+{%- else %} {{ type_ }}{%- endif -%};
+{%- if slot_range_as_union %}
+{{ slot_range_as_union }}
+{% endif -%}

linkml/generators/sqltablegen.py

@@ -149,8 +149,7 @@ class SQLTableGenerator(Generator):
     relative_slot_num: bool = False
     default_length_oracle: int = ORACLE_MAX_VARCHAR_LENGTH
     generate_abstract_class_ddl: bool = True
-    autogenerate_pk_index: bool = True
-    autogenerate_fk_index: bool = True
+    autogenerate_index: bool = True
 
     def serialize(self, **kwargs: dict[str, Any]) -> str:
         return self.generate_ddl(**kwargs)
@@ -235,8 +234,8 @@ class SQLTableGenerator(Generator):
                         fk = sql_name(self.get_id_or_key(s.range, sv))
                         args = [ForeignKey(fk)]
                     field_type = self.get_sql_range(s, schema)
-                    fk_index_cond = (s.key or s.identifier) and self.autogenerate_fk_index
-                    pk_index_cond = is_pk and self.autogenerate_pk_index
+                    fk_index_cond = (s.key or s.identifier) and self.autogenerate_index
+                    pk_index_cond = is_pk and self.autogenerate_index
                     is_index = fk_index_cond or pk_index_cond
                     col = Column(
                         sql_name(sn),
@@ -266,18 +265,21 @@ class SQLTableGenerator(Generator):
                     sql_uc = UniqueConstraint(*sql_names)
                     cols.append(sql_uc)
                     # Anything that has a unique constraint should have an associated index with it
-                    uc_index_name = sql_name(cn)
-                    for name in sql_names:
-                        uc_index_name = uc_index_name + "_" + name
-                    uc_index_name = uc_index_name + "_idx"
-                    is_duplicate = self.check_duplicate_entry_names(autogenerated_item_names, sql_name(uc_index_name))
-                    if not is_duplicate:
-                        sql_names = [sql_name(uc_index_name)] + sql_names
-                        uc_index = Index(*sql_names)
-                        cols.append(uc_index)
-                        autogenerated_item_names.append(sql_name(uc_index_name))
+                    if self.autogenerate_index:
+                        uc_index_name = sql_name(cn)
+                        for name in sql_names:
+                            uc_index_name = uc_index_name + "_" + name
+                        uc_index_name = uc_index_name + "_idx"
+                        is_duplicate = self.check_duplicate_entry_names(
+                            autogenerated_item_names, sql_name(uc_index_name)
+                        )
+                        if not is_duplicate:
+                            sql_names = [sql_name(uc_index_name)] + sql_names
+                            uc_index = Index(*sql_names)
+                            cols.append(uc_index)
+                            autogenerated_item_names.append(sql_name(uc_index_name))
             if not c.abstract or (c.abstract and self.generate_abstract_class_ddl):
-                for tag, annotation in c.annotations.items():
+                for tag, annotation in sorted(c.annotations.items()):
                     if tag == "index":
                         value_dict = {k: annotation for k, annotation in annotation.value._items()}
                         for key, value in value_dict.items():
@@ -424,7 +426,7 @@ class SQLTableGenerator(Generator):
 )
 @click.option(
     "--autogenerate_index",
-    default=False,
+    default=True,
     show_default=True,
     help="Enable the creation of indexes on all columns generated",
 )

linkml/generators/yarrrmlgen.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import os
+from typing import Any, TextIO
+
+import click
+import yaml
+from linkml_runtime.linkml_model.meta import ClassDefinition, SchemaDefinition
+from linkml_runtime.utils.schemaview import SchemaView
+
+from linkml._version import __version__
+from linkml.utils.generator import Generator, shared_arguments
+
+# defaults
+DEFAULT_SOURCE_JSON = "data.json~jsonpath"
+DEFAULT_SOURCE_CSV = "data.csv~csv"
+DEFAULT_ITERATOR = "$.items[*]"  # generic top-level array
+
+
+class _YamlDumper(yaml.Dumper):
+    # keep list indentation stable
+    def increase_indent(self, flow: bool = False, indentless: bool = False):
+        return super().increase_indent(flow, False)
+
+
+class YarrrmlGenerator(Generator):
+    """LinkML -> YARRRML exporter."""
+
+    generatorname = os.path.basename(__file__)
+    generatorversion = "0.2.0"
+    valid_formats = ["yml", "yaml"]
+    visit_all_class_slots = False
+
+    def __init__(self, schema: str | TextIO | SchemaDefinition, format: str = "yml", **kwargs):
+        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)
+
+        self.schemaview = SchemaView(schema)
+        self.schema: SchemaDefinition = self.schemaview.schema
+
+        self.format = format
+
+        # 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
+    def serialize(self, **args) -> str:
+        data = yaml.dump(
+            self.as_dict(),
+            Dumper=_YamlDumper,
+            sort_keys=False,
+            default_flow_style=False,
+            allow_unicode=True,
+        )
+        return data
+
+    def as_dict(self) -> dict[str, Any]:
+        sv = self.schemaview
+        mappings = {}
+        for cls in sv.all_classes().values():
+            if not (sv.get_identifier_slot(cls.name) or sv.get_key_slot(cls.name)):
+                continue
+
+            mapping = {
+                "s": self._subject_template_for_class(cls),
+                "po": self._po_list_for_class(cls),
+            }
+            if self._is_json_source():
+                mapping["sources"] = [[self.source, self._iterator_for_class(cls)]]
+            else:
+                mapping["sources"] = [[self.source]]
+
+            mappings[str(cls.name)] = mapping
+
+        return {"prefixes": self._prefixes(), "mappings": mappings}
+
+    # helpers
+    def _is_json_source(self) -> bool:
+        return "~jsonpath" in (self.source or "")
+
+    def _prefixes(self) -> dict[str, str]:
+        px: dict[str, str] = {}
+        if self.schema.prefixes:
+            for p in self.schema.prefixes.values():
+                if p.prefix_prefix and p.prefix_reference:
+                    px[str(p.prefix_prefix)] = str(p.prefix_reference)
+        px.setdefault("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
+        return px
+
+    def _iterator_for_class(self, c: ClassDefinition) -> str:
+        # supports {Class}
+        return self.iterator_template.replace("{Class}", c.name)
+
+    def _subject_template_for_class(self, c: ClassDefinition) -> str:
+        sv = self.schemaview
+        default_prefix = sv.schema.default_prefix or "ex"
+        id_slot = sv.get_identifier_slot(c.name)
+        if id_slot:
+            return f"{default_prefix}:$({id_slot.name})"
+        key_slot = sv.get_key_slot(c.name)
+        if key_slot:
+            return f"{default_prefix}:$({key_slot.name})"
+        return f"{default_prefix}:{c.name}/$(subject_id)"  # safe fallback
+
+    def _po_list_for_class(self, c: ClassDefinition) -> list[dict[str, Any]]:
+        sv = self.schemaview
+        po = []
+        class_curie = sv.get_uri(c, expand=False)
+        if class_curie:
+            po.append({"p": "rdf:type", "o": str(class_curie)})
+
+        default_prefix = sv.schema.default_prefix or "ex"
+
+        for s in sv.class_induced_slots(c.name):
+            pred = sv.get_uri(s, expand=False) or f"{default_prefix}:{s.name}"
+            decl = sv.get_slot(s.name)
+            alias = decl.alias if decl and decl.alias else s.alias
+            var = alias or s.name
+
+            is_obj = sv.get_class(s.range) is not None if s.range else False
+            if is_obj:
+                inlined = None
+                if decl and decl.inlined is not None:
+                    inlined = decl.inlined
+                if inlined is False:
+                    po.append({"p": pred, "o": {"value": f"$({var})", "type": "iri"}})
+                continue
+
+            po.append({"p": pred, "o": f"$({var})"})
+        return po
+
+
+@shared_arguments(YarrrmlGenerator)
+@click.command(name="yarrrml")
+@click.option(
+    "--source",
+    help="YARRRML source shorthand, e.g., data.json~jsonpath or data.csv~csv (TSV works too)",
+)
+@click.option(
+    "--iterator-template",
+    help='JSONPath iterator template; supports {Class}, default: "$.items[*]"',
+)
+@click.version_option(__version__, "-V", "--version")
+def cli(yamlfile, source, iterator_template, **args):
+    """Generate YARRRML mappings from a LinkML schema."""
+    if source:
+        args["source"] = source
+    if iterator_template:
+        args["iterator_template"] = iterator_template
+    gen = YarrrmlGenerator(yamlfile, **args)
+    print(gen.serialize(**args))
+
+
+if __name__ == "__main__":
+    cli()