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

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

@@ -0,0 +1,310 @@
+#[cfg(feature = "serde")]
+use serde::{de::{DeserializeOwned, IntoDeserializer}, Deserialize, Deserializer};
+#[cfg(feature = "serde")]
+use serde::de::Error;
+#[cfg(feature = "serde")]
+use serde_value::{Value, ValueDeserializer};
+#[cfg(feature = "serde")]
+use std::collections::{BTreeMap, HashMap};
+#[cfg(all(feature = "serde", feature = "pyo3"))]
+use pyo3::prelude::*;
+#[cfg(all(feature = "serde", feature = "pyo3"))]
+use pyo3::types::{PyAny, PyDict, PyList, PyTuple};
+
+#[cfg(feature = "serde")]
+pub trait InlinedPair: Sized {
+    type Key: std::hash::Hash + Eq + serde::de::DeserializeOwned + Clone + Ord;
+    type Value: serde::de::DeserializeOwned;
+    type Error: std::fmt::Display;
+
+    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;
+}
+
+#[cfg(feature = "serde")]
+impl<T> InlinedPair for Box<T>
+where
+    T: InlinedPair + ?Sized,           // allow unsized boxes too
+{
+    type Key   = T::Key;
+    type Value = T::Value;
+    type Error = T::Error;
+
+    #[inline]
+    fn from_pair_mapping(k: Self::Key, v: Value) -> Result<Self, Self::Error> {
+        T::from_pair_mapping(k, v).map(|x| Box::new(x))
+    }
+
+    #[inline]
+    fn from_pair_simple(k: Self::Key, v: Value) -> Result<Self, Self::Error>  {
+        T::from_pair_simple(k, v).map(|x| Box::new(x))
+    }
+
+    #[inline]
+    fn extract_key(&self) -> &Self::Key {
+        T::extract_key(self)
+     }
+
+}
+
+#[cfg(feature = "serde")]
+#[allow(dead_code)]
+pub fn deserialize_inlined_dict_list<'de, D, T>(de: D) -> Result<Vec<T>, D::Error>
+where
+    D: Deserializer<'de>,
+    T: InlinedPair,
+{
+    let raw: BTreeMap<T::Key, Value> = BTreeMap::deserialize(de)?;
+    raw.into_iter().map(|(k, v)| {
+        let obj = T::from_pair_mapping(k.clone(), v).map_err(D::Error::custom)?;
+        Ok(obj)
+    }).collect()
+
+}
+
+#[cfg(feature = "serde")]
+pub fn deserialize_inlined_dict_map<'de, D, T>(
+    de: D,
+) -> Result<HashMap<T::Key, T>, D::Error>
+where
+    D: Deserializer<'de>,
+    T: InlinedPair + Deserialize<'de>,
+{
+
+    // Parse into a generic AST once
+    let ast: Value = Value::deserialize(de)?;
+
+    match ast {
+        // ---------- { key : value } form ----------
+        Value::Map(m) => {
+            let mut out = HashMap::with_capacity(m.len());
+            for (k_ast, v_ast) in m {
+                // 1) convert key and value separately
+                let key: T::Key = Deserialize::deserialize(
+                    ValueDeserializer::<D::Error>::new(k_ast)
+                ).map_err(D::Error::custom)?;
+
+
+                // ----------------- decide by the *value* shape
+                let obj = match v_ast {
+                    // (1) full object (mapping) -> deserialize directly
+                    Value::Map(_) => {
+                        let m: Value = Deserialize::deserialize(
+                            ValueDeserializer::<D::Error>::new(v_ast)
+                        ).map_err(D::Error::custom)?;
+                        T::from_pair_mapping(key.clone(), m).map_err(D::Error::custom)?
+                    }
+                    other => {
+                        T::from_pair_simple(key.clone(), other).map_err(D::Error::custom)?
+                    }
+                };
+
+
+                out.insert(key, obj);
+            }
+            Ok(out)
+        }
+
+        // ---------- [ value, ... ] form -------------
+        Value::Seq(seq) => {
+            let mut out = HashMap::with_capacity(seq.len());
+            for v_ast in seq {
+                let val: T = Deserialize::deserialize(
+                    ValueDeserializer::<D::Error>::new(v_ast)
+                ).map_err(D::Error::custom)?;
+
+                let key = val.extract_key().clone();
+                if out.insert(key, val).is_some() {
+                    return Err(D::Error::custom("duplicate key"));
+                }
+            }
+            Ok(out)
+        }
+
+        _ => Err(D::Error::custom("expected mapping or sequence")),
+    }
+}
+
+#[cfg(feature = "serde")]
+pub fn deserialize_inlined_dict_map_optional<'de, D, T>(
+    de: D,
+) -> Result<Option<HashMap<T::Key, T>>, D::Error>
+where
+    D: Deserializer<'de>,
+    T: InlinedPair + Deserialize<'de>,
+{
+    let ast: Value = Value::deserialize(de)?;
+    match ast {
+        Value::Unit => Ok(None),
+        Value::Map(_) | Value::Seq(_) => {
+            let map = deserialize_inlined_dict_map(ValueDeserializer::<D::Error>::new(ast))?;
+            Ok(Some(map))
+        }
+        _ => Err(D::Error::custom("expected mapping, sequence, or unit")),
+    }
+}
+
+
+#[cfg(feature = "serde")]
+#[allow(dead_code)]
+pub fn deserialize_inlined_dict_list_optional<'de, D, T>(
+    de: D,
+) -> Result<Option<Vec<T>>, D::Error>
+where
+    D: Deserializer<'de>,
+    T: InlinedPair + Deserialize<'de>,
+{
+    let ast: Value = Value::deserialize(de)?;
+    match ast {
+        Value::Unit => Ok(None),
+        Value::Map(_) => {
+            let list = deserialize_inlined_dict_list(ValueDeserializer::<D::Error>::new(ast))?;
+            Ok(Some(list))
+        }
+        Value::Seq(seq) => {
+            let mut out = Vec::with_capacity(seq.len());
+            for v_ast in seq {
+                let val: T = Deserialize::deserialize(ValueDeserializer::<D::Error>::new(v_ast))
+                    .map_err(D::Error::custom)?;
+                out.push(val);
+            }
+            Ok(Some(out))
+        }
+        _ => Err(D::Error::custom("expected mapping, sequence, or unit")),
+    }
+}
+
+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> {
+    let ast: Value = Value::deserialize(deserializer)?;
+    match ast {
+        Value::Seq(seq) => {
+            seq.into_iter()
+                .map(|v| T::deserialize(ValueDeserializer::<D::Error>::new(v)))
+                .collect()
+        }
+        Value::Unit => Ok(vec![]),
+        other => {
+            let single_value: T = Deserialize::deserialize(
+                ValueDeserializer::<D::Error>::new(other)
+            ).map_err(D::Error::custom)?;
+            Ok(vec![single_value])
+        }
+    }
+}
+
+
+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> {
+    let ast: Value = Value::deserialize(deserializer)?;
+    match ast {
+        Value::Unit => Ok(None),
+        _ => {
+            let d = deserialize_primitive_list_or_single_value(ValueDeserializer::<D::Error>::new(ast))?;
+            Ok(Some(d))
+        }
+    }
+}
+
+#[cfg(all(feature = "serde", feature = "pyo3"))]
+fn py_any_to_value(bound: &Bound<'_, PyAny>) -> PyResult<Value> {
+    if bound.is_none() {
+        return Ok(Value::Unit);
+    }
+
+    if let Ok(b) = bound.extract::<bool>() {
+        return Ok(Value::Bool(b));
+    }
+
+    if let Ok(i) = bound.extract::<i64>() {
+        return Ok(Value::I64(i));
+    }
+
+    if let Ok(f) = bound.extract::<f64>() {
+        return Ok(Value::F64(f));
+    }
+
+    if let Ok(s) = bound.extract::<String>() {
+        return Ok(Value::String(s));
+    }
+
+    if let Ok(dict_obj) = bound.getattr("__dict__") {
+        if let Ok(dict) = dict_obj.downcast::<PyDict>() {
+            let mut map: BTreeMap<Value, Value> = BTreeMap::new();
+            for (k, v) in dict.iter() {
+                let key_str: String = k.extract()?;
+                let val = py_any_to_value(&v)?;
+                map.insert(Value::String(key_str), val);
+            }
+            return Ok(Value::Map(map));
+        }
+    }
+
+    if let Ok(dict) = bound.downcast::<PyDict>() {
+        let mut map: BTreeMap<Value, Value> = BTreeMap::new();
+        for (k, v) in dict.iter() {
+            let key_str: String = k.extract()?;
+            let val = py_any_to_value(&v)?;
+            map.insert(Value::String(key_str), val);
+        }
+        return Ok(Value::Map(map));
+    }
+
+    if let Ok(list) = bound.downcast::<PyList>() {
+        let mut items = Vec::with_capacity(list.len());
+        for item in list.iter() {
+            items.push(py_any_to_value(&item)?);
+        }
+        return Ok(Value::Seq(items));
+    }
+
+    if let Ok(tuple) = bound.downcast::<PyTuple>() {
+        let mut items = Vec::with_capacity(tuple.len());
+        for item in tuple.iter() {
+            items.push(py_any_to_value(&item)?);
+        }
+        return Ok(Value::Seq(items));
+    }
+
+    Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
+        "unsupported value type for conversion",
+    ))
+}
+
+#[cfg(all(feature = "serde", feature = "pyo3"))]
+pub fn deserialize_py_any<'py, T>(bound: &Bound<'py, PyAny>) -> PyResult<T>
+where
+    T: DeserializeOwned,
+{
+    let value = py_any_to_value(bound)?;
+    let de = value.into_deserializer();
+    match serde_path_to_error::deserialize(de) {
+        Ok(ok) => Ok(ok),
+        Err(err) => Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+            format!("at `{}`: {}", err.path(), err.inner()),
+        )),
+    }
+}
+
+#[cfg(feature = "pyo3")]
+pub struct PyValue<T>(pub T);
+
+#[cfg(feature = "pyo3")]
+impl<T> PyValue<T> {
+    pub fn into_inner(self) -> T {
+        self.0
+    }
+}
+
+#[cfg(all(feature = "pyo3", feature = "serde"))]
+impl<'py, T> FromPyObject<'py> for PyValue<T>
+where
+    T: DeserializeOwned,
+{
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
+        deserialize_py_any(ob).map(PyValue)
+    }
+}

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

@@ -0,0 +1,61 @@
+    #[derive(Debug, Clone, PartialEq)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub enum {{ slot_name }}_range {
+    {% for r in ranges %}
+        {{ r }}({{ r }}){% if not loop.last %},
+    {% endif %}
+    {% endfor %}
+    }
+
+    #[cfg(feature = "pyo3")]
+    impl<'py> FromPyObject<'py> for {{ slot_name }}_range {
+        fn extract_bound(ob: &pyo3::Bound<'py, pyo3::types::PyAny>) -> pyo3::PyResult<Self> {
+    {% for t in ranges %}
+            if let Ok(val) = ob.extract::<{{ t }}>() {
+                return Ok({{ slot_name }}_range::{{ t }}(val));
+            }
+    {%- endfor -%}
+            Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
+                "invalid {{ slot_name }}",
+            ))
+        }
+    }
+
+    #[cfg(feature = "pyo3")]
+    impl<'py> IntoPyObject<'py> for {{ slot_name }}_range {
+        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 ranges %}
+                {{ slot_name }}_range::{{ t }}(val) => Ok(val.into_pyobject(py).map(move |b| <pyo3::Bound<'_, _> as Clone>::clone(&b).into_any())?),
+    {% endfor %}
+            }
+        }
+    }
+
+
+    #[cfg(feature = "pyo3")]
+    impl<'py> IntoPyObject<'py> for Box<{{ slot_name }}_range>
+    {
+        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<{{ slot_name }}_range> {
+        fn extract_bound(ob: &pyo3::Bound<'py, pyo3::types::PyAny>) -> pyo3::PyResult<Self> {
+            if let Ok(val) = ob.extract::<{{ slot_name  }}_range>() {
+                return Ok(Box::new(val));
+            }
+            Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
+                "invalid {{ slot_name }}",
+            ))
+        }
+    }

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

@@ -0,0 +1,75 @@
+{% if special_case_enabled and name == 'Anything' %}
+{% include 'anything.rs.jinja' %}
+{% elif special_case_enabled and name == 'AnyValue' %}
+pub type AnyValue = Anything;
+{% else %}
+{% if class_module %}
+{{ class_module }}
+{% endif %}
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "pyo3", pyclass(subclass, get_all, set_all))]
+{% if generate_merge %}
+#[derive(Merge)]
+{% endif %}
+pub struct {{ name }} {
+{% for property in properties %}
+{% filter indent(width=4, first=True, blank=False) %}
+{{ property }}
+{%- if not loop.last -%},{{ '\n' }}{% else %}{{ '\n' }}{%- endif -%}
+{% endfilter %}
+{% endfor %}
+}
+{% if properties | length > 0 %}
+#[cfg(feature = "pyo3")]
+#[pymethods]
+impl {{ name }} {
+    #[new]
+    #[pyo3(signature = ({{ constructor_signature }}))]
+    pub fn new({% for (n, t) in property_names_and_types %}{{ n }}: {{ t }}{% if not loop.last  %}, {% endif %}{% endfor %}) -> Self {
+{% for name, expr in constructor_conversions %}
+        let {{ name }} = {{ expr }};
+{% endfor %}
+        {{ name }}{{ "{" }}{% for (p, _) in property_names_and_types %}{{ p }}{% if not loop.last %}, {% endif %}{% endfor %}{{ "}" }}
+    }
+}
+
+#[cfg(feature = "pyo3")]
+impl<'py> IntoPyObject<'py> for Box<{{ 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<{{ name }}> {
+    fn extract_bound(ob: &pyo3::Bound<'py, pyo3::types::PyAny>) -> pyo3::PyResult<Self> {
+        if let Ok(val) = ob.extract::<{{ name }}>() {
+            return Ok(Box::new(val));
+        }
+        Err(PyErr::new::<pyo3::exceptions::PyTypeError, _>(
+            "invalid {{ name}}",
+        ))
+    }
+}
+
+{% if generate_merge %}
+impl {{ name }} {
+    pub fn merge_with(&mut self, other: &{{ name }}) {
+        self.merge(other.clone())
+    }
+}
+{% endif %}
+
+{% endif %}
+{% if as_key_value %}
+{{ as_key_value }}
+{% endif %}
+{% if struct_or_subtype_enum %}
+{{ struct_or_subtype_enum }}
+{% endif %}
+{% endif %}

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

@@ -0,0 +1,108 @@
+#[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       = String;
+    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 %}

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",
 )