linkml 1.8.2__py3-none-any.whl → 1.8.4__py3-none-any.whl

linkml/generators/pydanticgen/pydanticgen.py

@@ -41,9 +41,12 @@ from linkml.generators.pydanticgen.template import (
     PydanticModule,
     PydanticTemplateModel,
 )
+from linkml.generators.python.python_ifabsent_processor import PythonIfAbsentProcessor
 from linkml.utils import deprecation_warning
 from linkml.utils.generator import shared_arguments
-from linkml.utils.ifabsent_functions import ifabsent_value_declaration
+
+logger = logging.getLogger(__name__)
+
 
 if int(PYDANTIC_VERSION[0]) == 1:
     deprecation_warning("pydantic-v1")
@@ -67,7 +70,9 @@ def _get_pyrange(t: TypeDefinition, sv: SchemaView) -> str:
 DEFAULT_IMPORTS = (
     Imports()
     + Import(module="__future__", objects=[ObjectImport(name="annotations")])
-    + Import(module="datetime", objects=[ObjectImport(name="datetime"), ObjectImport(name="date")])
+    + Import(
+        module="datetime", objects=[ObjectImport(name="datetime"), ObjectImport(name="date"), ObjectImport(name="time")]
+    )
     + Import(module="decimal", objects=[ObjectImport(name="Decimal")])
     + Import(module="enum", objects=[ObjectImport(name="Enum")])
     + Import(module="re")
@@ -187,7 +192,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
     template_dir: Optional[Union[str, Path]] = None
     """
     Override templates for each PydanticTemplateModel.
-    
+
     Directory with templates that override the default :attr:`.PydanticTemplateModel.template`
     for each class. If a matching template is not found in the override directory,
     the default templates will be used.
@@ -216,7 +221,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         )
 
     """
-    imports: Optional[List[Import]] = None
+    imports: Optional[Union[List[Import], Imports]] = None
     """
     Additional imports to inject into generated module.
 
@@ -264,6 +269,13 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         else:
             from typing_extensions import Literal
 
+    """
+    sort_imports: bool = True
+    """
+    Before returning from :meth:`.PydanticGenerator.render`, sort imports with :meth:`.Imports.sort`
+
+    Default ``True``, but optional in case import order must be explicitly given,
+    eg. to avoid circular import errors in complex generator subclasses.
     """
     metadata_mode: Union[MetadataMode, str, None] = MetadataMode.AUTO
     """
@@ -356,8 +368,8 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         try:
             return compile_python(pycode)
         except NameError as e:
-            logging.error(f"Code:\n{pycode}")
-            logging.error(f"Error compiling generated python code: {e}")
+            logger.error(f"Code:\n{pycode}")
+            logger.error(f"Error compiling generated python code: {e}")
             raise e
 
     def _get_classes(self, sv: SchemaView) -> Tuple[List[ClassDefinition], Optional[List[ClassDefinition]]]:
@@ -446,11 +458,12 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
 
     def generate_slot(self, slot: SlotDefinition, cls: ClassDefinition) -> SlotResult:
         slot_args = {
-            k: slot._as_dict.get(k, None)
+            k: getattr(slot, k, None)
             for k in PydanticAttribute.model_fields.keys()
-            if slot._as_dict.get(k, None) is not None
+            if getattr(slot, k, None) is not None
         }
-        slot_args["name"] = underscore(slot.name)
+        slot_alias = slot.alias if slot.alias else slot.name
+        slot_args["name"] = underscore(slot_alias)
         slot_args["description"] = slot.description.replace('"', '\\"') if slot.description is not None else None
         predef = self.predefined_slot_values.get(camelcase(cls.name), {}).get(slot.name, None)
         if predef is not None:
@@ -526,6 +539,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         """
         if self._predefined_slot_values is None:
             sv = self.schemaview
+            ifabsent_processor = PythonIfAbsentProcessor(sv)
             slot_values = defaultdict(dict)
             for class_def in sv.all_classes().values():
                 for slot_name in sv.class_slots(class_def.name):
@@ -541,10 +555,10 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
                             slot.name
                         ]
                     elif slot.ifabsent is not None:
-                        value = ifabsent_value_declaration(slot.ifabsent, sv, class_def, slot)
+                        value = ifabsent_processor.process_slot(slot, class_def)
                         slot_values[camelcase(class_def.name)][slot.name] = value
 
-            self._predefined_slot_values = slot_values
+                self._predefined_slot_values = slot_values
 
         return self._predefined_slot_values
 
@@ -662,7 +676,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         else:
             # TODO: default ranges in schemagen
             # pyrange = 'str'
-            # logging.error(f'range: {s.range} is unknown')
+            # logger.error(f'range: {s.range} is unknown')
             raise Exception(f"range: {slot_range}")
         return pyrange
 
@@ -918,14 +932,20 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         return Import(module=module, objects=[ObjectImport(name=camelcase(class_name))], is_schema=True)
 
     def render(self) -> PydanticModule:
+        """
+        Render the schema to a :class:`PydanticModule` model
+        """
         sv: SchemaView
         sv = self.schemaview
 
         # imports
         imports = DEFAULT_IMPORTS
         if self.imports is not None:
-            for i in self.imports:
-                imports += i
+            if isinstance(self.imports, Imports):
+                imports += self.imports
+            else:
+                for i in self.imports:
+                    imports += i
         if self.split_mode == SplitMode.FULL:
             imports += self._get_imports()
 
@@ -962,13 +982,14 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         class_results = self.after_generate_classes(class_results, sv)
 
         classes = {r.cls.name: r.cls for r in class_results}
-
         injected_classes = self._clean_injected_classes(injected_classes)
 
+        imports.render_sorted = self.sort_imports
+
         module = PydanticModule(
             metamodel_version=self.schema.metamodel_version,
             version=self.schema.version,
-            python_imports=imports.imports,
+            python_imports=imports,
             base_model=base_model,
             injected_classes=injected_classes,
             enums=enums,
@@ -984,7 +1005,8 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
 
         Args:
             rendered_module ( :class:`.PydanticModule` ): Optional, if schema was previously
-                rendered with :meth:`.render` , use that, otherwise :meth:`.render` fresh.
+                rendered with :meth:`~.PydanticGenerator.render` , use that,
+                otherwise :meth:`~.PydanticGenerator.render` fresh.
         """
         if rendered_module is not None:
             module = rendered_module
@@ -1061,7 +1083,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
         # interpret all imported schema paths as relative to that
         output_path.parent.mkdir(parents=True, exist_ok=True)
         serialized = generator.serialize(rendered_module=rendered)
-        with open(output_path, "w") as ofile:
+        with open(output_path, "w", encoding="utf-8") as ofile:
             ofile.write(serialized)
 
         results.append(
@@ -1080,7 +1102,7 @@ class PydanticGenerator(OOCodeGenerator, LifecycleMixin):
             rel_path = _import_to_path(generated_import.module)
             abs_path = (output_path.parent / rel_path).resolve()
             abs_path.parent.mkdir(parents=True, exist_ok=True)
-            with open(abs_path, "w") as ofile:
+            with open(abs_path, "w", encoding="utf-8") as ofile:
                 ofile.write(serialized)
 
             results.append(
@@ -1123,7 +1145,7 @@ def _ensure_inits(paths: List[Path]):
     common_path = Path(os.path.commonpath(paths))
 
     if not (ipath := (common_path / "__init__.py")).exists():
-        with open(ipath, "w") as ifile:
+        with open(ipath, "w", encoding="utf-8") as ifile:
             ifile.write(" \n")
 
     for path in paths:
@@ -1131,7 +1153,7 @@ def _ensure_inits(paths: List[Path]):
         path = path.parent
         while path != common_path:
             if not (ipath := (path / "__init__.py")).exists():
-                with open(ipath, "w") as ifile:
+                with open(ipath, "w", encoding="utf-8") as ifile:
                     ifile.write(" \n")
             path = path.parent
 
@@ -1144,9 +1166,9 @@ def _ensure_inits(paths: List[Path]):
     help="""
 Optional jinja2 template directory to use for class generation.
 
-Pass a directory containing templates with the same name as any of the default 
-:class:`.PydanticTemplateModel` templates to override them. The given directory will be 
-searched for matching templates, and use the default templates as a fallback 
+Pass a directory containing templates with the same name as any of the default
+:class:`.PydanticTemplateModel` templates to override them. The given directory will be
+searched for matching templates, and use the default templates as a fallback
 if an override is not found
 
 Available templates to override:

linkml/generators/pydanticgen/template.py

@@ -1,5 +1,6 @@
+import sys
 from importlib.util import find_spec
-from typing import Any, ClassVar, Dict, Generator, List, Literal, Optional, Union
+from typing import Any, ClassVar, Dict, Generator, List, Literal, Optional, Tuple, Union, get_args
 
 from jinja2 import Environment, PackageLoader
 from pydantic import BaseModel, Field, field_validator
@@ -28,6 +29,14 @@ else:
         return f
 
 
+IMPORT_GROUPS = Literal["future", "stdlib", "thirdparty", "local", "conditional"]
+"""
+See :attr:`.Import.group` and :attr:`.Imports.sort`
+
+Order of this literal is used in sort and therefore not arbitrary.
+"""
+
+
 class PydanticTemplateModel(TemplateModel):
     """
     Metaclass to render pydantic models with jinja templates.
@@ -292,6 +301,28 @@ class Import(PydanticTemplateModel):
     Used primarily in split schema generation, see :func:`.pydanticgen.generate_split` for example usage.
     """
 
+    @computed_field
+    def group(self) -> IMPORT_GROUPS:
+        """
+        Import group used when sorting
+
+        * ``future`` - from `__future__` import...
+        * ``stdlib`` - ... the standard library
+        * ``thirdparty`` - other dependencies not in the standard library
+        * ``local`` - relative imports (eg. from split generation)
+        * ``conditional`` - a :class:`.ConditionalImport`
+        """
+        if self.module == "__future__":
+            return "future"
+        elif sys.version_info.minor >= 10 and self.module in sys.stdlib_module_names:
+            return "stdlib"
+        elif sys.version_info.minor < 10 and self.module in _some_stdlib_module_names:
+            return "stdlib"
+        elif self.module.startswith("."):
+            return "local"
+        else:
+            return "thirdparty"
+
     def merge(self, other: "Import") -> List["Import"]:
         """
         Merge one import with another, see :meth:`.Imports` for an example.
@@ -346,6 +377,16 @@ class Import(PydanticTemplateModel):
             # one is a module, the other imports objects, keep both
             return [self, other]
 
+    def sort(self) -> None:
+        """
+        Sort imported objects
+
+        * First by whether the first letter is capitalized or not,
+        * Then alphabetically (by object name rather than alias)
+        """
+        if self.objects:
+            self.objects = sorted(self.objects, key=lambda obj: (obj.name[0].islower(), obj.name))
+
 
 class ConditionalImport(Import):
     """
@@ -391,6 +432,17 @@ class ConditionalImport(Import):
     condition: str
     alternative: Import
 
+    @computed_field
+    def group(self) -> Literal["conditional"]:
+        return "conditional"
+
+    def sort(self) -> None:
+        """
+        :meth:`.Import.sort` called for self and :attr:`.alternative`
+        """
+        super(ConditionalImport, self).sort()
+        self.alternative.sort()
+
 
 class Imports(PydanticTemplateModel):
     """
@@ -427,6 +479,10 @@ class Imports(PydanticTemplateModel):
     template: ClassVar[str] = "imports.py.jinja"
 
     imports: List[Union[Import, ConditionalImport]] = Field(default_factory=list)
+    group_order: Tuple[str, ...] = get_args(IMPORT_GROUPS)
+    """Order in which to sort imports by their :attr:`.Import.group`"""
+    render_sorted: bool = True
+    """When rendering, render in sorted groups"""
 
     @classmethod
     def _merge(
@@ -484,13 +540,17 @@ class Imports(PydanticTemplateModel):
                         break
 
         # SPECIAL CASE - __future__ annotations must happen at the top of a file
+        # sort here outside of sort method because our imports are invalid without it,
+        # where calling ``sort`` should be optional.
         imports = sorted(imports, key=lambda i: i.module == "__future__", reverse=True)
         return imports
 
     def __add__(self, other: Union[Import, "Imports", List[Import]]) -> "Imports":
         imports = self.imports.copy()
         imports = self._merge(imports, other)
-        return Imports.model_construct(imports=imports)
+        return Imports.model_construct(
+            imports=imports, **{k: getattr(self, k, None) for k in self.model_fields if k != "imports"}
+        )
 
     def __len__(self) -> int:
         return len(self.imports)
@@ -552,6 +612,36 @@ class Imports(PydanticTemplateModel):
             merged_imports = cls._merge(merged_imports, i)
         return merged_imports
 
+    @computed_field
+    def import_groups(self) -> List[IMPORT_GROUPS]:
+        """
+        List of what group each import belongs to
+        """
+        return [i.group for i in self.imports]
+
+    def sort(self) -> None:
+        """
+        Sort imports recursively, mimicking isort:
+
+        * First by :attr:`.Import.group` according to :attr:`.Imports.group_order`
+        * Then by whether the :class:`.Import` has any objects
+          (``import module`` comes before ``from module import name``)
+        * Then alphabetically by module name
+        """
+
+        def _sort_key(i: Import) -> Tuple[int, int, str]:
+            return (self.group_order.index(i.group), int(i.objects is not None), i.module)
+
+        imports = sorted(self.imports, key=_sort_key)
+        for i in imports:
+            i.sort()
+        self.imports = imports
+
+    def render(self, environment: Optional[Environment] = None, black: bool = False) -> str:
+        if self.render_sorted:
+            self.sort()
+        return super(Imports, self).render(environment=environment, black=black)
+
 
 class PydanticModule(PydanticTemplateModel):
     """
@@ -565,7 +655,7 @@ class PydanticModule(PydanticTemplateModel):
     version: Optional[str] = None
     base_model: PydanticBaseModel = PydanticBaseModel()
     injected_classes: Optional[List[str]] = None
-    python_imports: List[Union[Import, ConditionalImport]] = Field(default_factory=list)
+    python_imports: Union[Imports, List[Union[Import, ConditionalImport]]] = Imports()
     enums: Dict[str, PydanticEnum] = Field(default_factory=dict)
     classes: Dict[str, PydanticClass] = Field(default_factory=dict)
     meta: Optional[Dict[str, Any]] = None
@@ -573,6 +663,21 @@ class PydanticModule(PydanticTemplateModel):
     Metadata for the schema to be included in a linkml_meta module-level instance of LinkMLMeta
     """
 
+    @field_validator("python_imports", mode="after")
+    @classmethod
+    def cast_imports(cls, imports: Union[Imports, List[Union[Import, ConditionalImport]]]) -> Imports:
+        if isinstance(imports, list):
+            imports = Imports(imports=imports)
+        return imports
+
     @computed_field
     def class_names(self) -> List[str]:
         return [c.name for c in self.classes.values()]
+
+
+_some_stdlib_module_names = {"copy", "datetime", "decimal", "enum", "inspect", "os", "re", "sys", "typing"}
+"""
+sys.stdlib_module_names is only present in 3.10 and later
+so we make a cheap copy of the stdlib modules that we commonly use here,
+but this should be removed whenever support for 3.9 is dropped.
+"""

linkml/generators/pydanticgen/templates/imports.py.jinja

@@ -20,12 +20,20 @@ from {{ module }} import (
     {%- endif %}
 {%- endif %}
 {% endmacro %}
+{#- For when used with Import model -#}
 {%- if module %}
 {{ import_(module, alias, objects) }}
 {% endif -%}
 {#- For when used with Imports container -#}
 {%- if imports -%}
-{%- for i in imports -%}
-{{ i }}
-{%- endfor -%}
+    {%- if render_sorted -%}
+        {% for i in range(imports | length) %}
+{{ imports[i] }}
+{%- if not loop.last and import_groups[i] != import_groups[i+1] %}{{ '\n' }}{% endif -%}
+        {% endfor %}
+    {%- else -%}
+        {%- for import in imports -%}
+{{ import }}
+        {%- endfor -%}
+    {%- endif -%}
 {% endif -%}

linkml/generators/pydanticgen/templates/module.py.jinja

@@ -1,6 +1,4 @@
-{% for import in python_imports %}
-{{ import }}
-{%- endfor -%}
+{{ python_imports }}
 
 metamodel_version = "{{metamodel_version}}"
 version = "{{version if version else None}}"

linkml/generators/pydanticgen/templates/validator.py.jinja

@@ -3,9 +3,9 @@
         pattern=re.compile(r"{{pattern}}")
         if isinstance(v,list):
             for element in v:
-                if not pattern.match(element):
+                if isinstance(v, str) and not pattern.match(element):
                     raise ValueError(f"Invalid {{name}} format: {element}")
         elif isinstance(v,str):
             if not pattern.match(v):
                 raise ValueError(f"Invalid {{name}} format: {v}")
-        return v
+        return v

linkml/generators/python/__init__.py

@@ -0,0 +1 @@
+__all__ = ["python_ifabsent_processor"]

linkml/generators/python/python_ifabsent_processor.py

@@ -0,0 +1,92 @@
+from linkml_runtime.linkml_model import (
+    ClassDefinition,
+    EnumDefinitionName,
+    SlotDefinition,
+)
+
+from linkml.generators.common.ifabsent_processor import IfAbsentProcessor
+
+
+class PythonIfAbsentProcessor(IfAbsentProcessor):
+    UNIMPLEMENTED_DEFAULT_VALUES = ["class_curie", "class_uri", "slot_uri", "slot_curie", "default_range", "default_ns"]
+
+    def map_custom_default_values(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition) -> (bool, str):
+        if default_value in self.UNIMPLEMENTED_DEFAULT_VALUES:
+            return True, None
+
+        if default_value == "bnode":
+            return True, "bnode()"
+
+        return False, None
+
+    def map_string_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return self._strval(default_value)
+
+    def map_boolean_true_default_value(self, slot: SlotDefinition, cls: ClassDefinition):
+        return "True"
+
+    def map_boolean_false_default_value(self, slot: SlotDefinition, cls: ClassDefinition):
+        return "False"
+
+    def map_integer_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return default_value
+
+    def map_float_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return default_value
+
+    def map_double_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return default_value
+
+    def map_decimal_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return default_value
+
+    def map_time_default_value(self, hour: str, minutes: str, seconds: str, slot: SlotDefinition, cls: ClassDefinition):
+        return f"time({int(hour)}, {int(minutes)}, {int(seconds)})"
+
+    def map_date_default_value(self, year: str, month: str, day: str, slot: SlotDefinition, cls: ClassDefinition):
+        return f"date({int(year)}, {int(month)}, {int(day)})"
+
+    def map_datetime_default_value(
+        self,
+        year: str,
+        month: str,
+        day: str,
+        hour: str,
+        minutes: str,
+        seconds: str,
+        slot: SlotDefinition,
+        cls: ClassDefinition,
+    ):
+        return f"datetime({int(year)}, {int(month)}, {int(day)}, " f"{int(hour)}, {int(minutes)}, {int(seconds)})"
+
+    def map_uri_or_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return self._uri_for(default_value)
+
+    def map_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return self._uri_for(default_value)
+
+    def map_uri_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        return self._uri_for(default_value)
+
+    def map_enum_default_value(
+        self, enum_name: EnumDefinitionName, permissible_value_name: str, slot: SlotDefinition, cls: ClassDefinition
+    ):
+        return f"{enum_name}.{permissible_value_name}"
+
+    def map_nc_name_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_object_identifier_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_node_identifier_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_json_pointer_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_json_path_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    def map_sparql_path_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()