linkml 1.8.3__tar.gz → 1.8.5__tar.gz

{linkml-1.8.3 → linkml-1.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.8.3
+Version: 1.8.5
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink
@@ -24,6 +24,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Provides-Extra: black
+Provides-Extra: numpydantic
 Provides-Extra: shacl
 Provides-Extra: tests
 Requires-Dist: antlr4-python3-runtime (>=4.9.0,<4.10)
@@ -37,6 +38,7 @@ Requires-Dist: jsonasobj2 (>=1.0.3,<2.0.0)
 Requires-Dist: jsonschema[format] (>=4.0.0)
 Requires-Dist: linkml-dataops
 Requires-Dist: linkml-runtime (>=1.8.1,<2.0.0)
+Requires-Dist: numpydantic (>=1.6.1) ; (python_version >= "3.9") and (extra == "numpydantic" or extra == "tests")
 Requires-Dist: openpyxl
 Requires-Dist: parse
 Requires-Dist: prefixcommons (>=0.1.7)

{linkml-1.8.3 → linkml-1.8.5}/linkml/generators/__init__.py

@@ -10,6 +10,7 @@ from linkml.generators.jsonschemagen import JsonSchemaGenerator
 from linkml.generators.owlgen import OwlSchemaGenerator
 from linkml.generators.pydanticgen import PydanticGenerator
 from linkml.generators.pythongen import PythonGenerator
+from linkml.generators.rdfgen import RDFGenerator
 from linkml.generators.shaclgen import ShaclGenerator
 from linkml.generators.shexgen import ShExGenerator
 from linkml.generators.sqlalchemygen import SQLAlchemyGenerator
@@ -50,6 +51,7 @@ __all__ = [
     "ShExGenerator",
     "SQLAlchemyGenerator",
     "SQLTableGenerator",
+    "RDFGenerator",
 ]
 
 # TODO: deprecate usage of these

{linkml-1.8.3 → linkml-1.8.5}/linkml/generators/common/ifabsent_processor.py

@@ -1,7 +1,13 @@
 import abc
 import re
+import sys
 from abc import ABC
-from typing import Any, Optional
+from typing import Any, Optional, Type, Union
+
+if sys.version_info < (3, 10):
+    from typing_extensions import TypeAlias
+else:
+    from typing import TypeAlias
 
 from linkml_runtime import SchemaView
 from linkml_runtime.linkml_model import (
@@ -18,6 +24,7 @@ from linkml_runtime.linkml_model import (
     String,
     Time,
     Uri,
+    types,
 )
 from linkml_runtime.linkml_model.types import (
     Curie,
@@ -31,6 +38,34 @@ from linkml_runtime.linkml_model.types import (
     Uriorcurie,
 )
 
+TYPES_TYPE: TypeAlias = Union[
+    Type[Boolean],
+    Type[Curie],
+    Type[Date],
+    Type[DateOrDatetime],
+    Type[Datetime],
+    Type[Decimal],
+    Type[Double],
+    Type[Float],
+    Type[Integer],
+    Type[Jsonpath],
+    Type[Jsonpointer],
+    Type[Ncname],
+    Type[Nodeidentifier],
+    Type[Objectidentifier],
+    Type[Sparqlpath],
+    Type[String],
+    Type[Time],
+    Type[Uri],
+    Type[Uriorcurie],
+]
+
+TYPES = [
+    t
+    for t in types.__dict__.values()
+    if isinstance(t, type) and t.__module__ == types.__name__ and hasattr(t, "type_name")
+]
+
 
 class IfAbsentProcessor(ABC):
     """
@@ -39,7 +74,7 @@ class IfAbsentProcessor(ABC):
     See `<https://w3id.org/linkml/ifabsent>`_.
     """
 
-    ifabsent_regex = re.compile("""(?:(?P<type>\w+)\()?[\"\']?(?P<default_value>[^\(\)\"\')]*)[\"\']?\)?""")
+    ifabsent_regex = re.compile(r"""(?:(?P<type>\w+)\()?[\"\']?(?P<default_value>[^\(\)\"\')]*)[\"\']?\)?""")
 
     def __init__(self, schema_view: SchemaView):
         self.schema_view = schema_view
@@ -61,10 +96,12 @@ class IfAbsentProcessor(ABC):
         if mapped:
             return custom_default_value
 
-        if slot.range == String.type_name:
+        base_type = self._base_type(slot.range)
+
+        if base_type is String:
             return self.map_string_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Boolean.type_name:
+        if base_type is Boolean:
             if re.match(r"^[Tt]rue$", ifabsent_default_value):
                 return self.map_boolean_true_default_value(slot, cls)
             elif re.match(r"^[Ff]alse$", ifabsent_default_value):
@@ -75,19 +112,19 @@ class IfAbsentProcessor(ABC):
                     f"value"
                 )
 
-        if slot.range == Integer.type_name:
+        if base_type is Integer:
             return self.map_integer_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Float.type_name:
+        if base_type is Float:
             return self.map_float_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Double.type_name:
+        if base_type is Double:
             return self.map_double_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Decimal.type_name:
+        if base_type is Decimal:
             return self.map_decimal_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Time.type_name:
+        if base_type is Time:
             match = re.match(r"^(\d{2}):(\d{2}):(\d{2}).*$", ifabsent_default_value)
             if match:
                 return self.map_time_default_value(match[1], match[2], match[3], slot, cls)
@@ -97,7 +134,7 @@ class IfAbsentProcessor(ABC):
                 )
 
         # TODO manage timezones and offsets
-        if slot.range == Date.type_name:
+        if base_type is Date:
             match = re.match(r"^(\d{4})-(\d{2})-(\d{2})$", ifabsent_default_value)
             if match:
                 return self.map_date_default_value(match[1], match[2], match[3], slot, cls)
@@ -107,7 +144,7 @@ class IfAbsentProcessor(ABC):
                 )
 
         # TODO manage timezones and offsets
-        if slot.range == Datetime.type_name:
+        if base_type is Datetime:
             match = re.match(r"^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}).*$", ifabsent_default_value)
             if match:
                 return self.map_datetime_default_value(
@@ -120,7 +157,7 @@ class IfAbsentProcessor(ABC):
                 )
 
         # TODO manage timezones and offsets
-        if slot.range == DateOrDatetime.type_name:
+        if base_type is DateOrDatetime:
             match = re.match(r"^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2}))?.*$", ifabsent_default_value)
             if match and (match[4] is None or match[5] is None or match[6] is None):
                 return self.map_date_default_value(match[1], match[2], match[3], slot, cls)
@@ -134,31 +171,31 @@ class IfAbsentProcessor(ABC):
                     f"datetime value"
                 )
 
-        if slot.range == Uri.type_name:
+        if base_type is Uri:
             return self.map_uri_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Curie.type_name:
+        if base_type is Curie:
             return self.map_curie_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Uriorcurie.type_name:
+        if base_type is Uriorcurie:
             return self.map_uri_or_curie_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Ncname.type_name:
+        if base_type is Ncname:
             return self.map_nc_name_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Objectidentifier.type_name:
+        if base_type is Objectidentifier:
             return self.map_object_identifier_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Nodeidentifier.type_name:
+        if base_type is Nodeidentifier:
             return self.map_node_identifier_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Jsonpointer.type_name:
+        if base_type is Jsonpointer:
             return self.map_json_pointer_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Jsonpath.type_name:
+        if base_type is Jsonpath:
             return self.map_json_path_default_value(ifabsent_default_value, slot, cls)
 
-        if slot.range == Sparqlpath.type_name:
+        if base_type is Sparqlpath:
             return self.map_sparql_path_default_value(ifabsent_default_value, slot, cls)
 
         # -----------------------
@@ -173,6 +210,46 @@ class IfAbsentProcessor(ABC):
 
         raise ValueError(f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot could not be processed")
 
+    def _base_type(self, range_: str) -> Optional[TYPES_TYPE]:
+        """
+        Find the linkml base type that corresponds to either a matching type_name or custom type
+
+        First check for an explicit match of the range == TypeDefinition.type_name
+        Then check for explicit inheritance via typeof
+        Finally check for implicit matching via matching base
+
+        Don't raise here, just return None in case another method of resolution like enums are
+        available
+        """
+        # first check for matching type using type_name - ie. range is already a base type
+
+        for typ in TYPES:
+            if range_ == typ.type_name:
+                return typ
+
+        # if we're not a type, return None to indicate that, e.g. if an enum's permissible_value
+        if range_ not in self.schema_view.all_types(imports=True):
+            return
+
+        # then check explicit descendents of types
+        # base types do not inherit from one another, so the last ancestor is always a base type
+        # if it is inheriting from a base type
+        ancestor = self.schema_view.type_ancestors(range_)[-1]
+        for typ in TYPES:
+            if ancestor == typ.type_name:
+                return typ
+
+        # finally check if we have a matching base
+        induced_typ = self.schema_view.induced_type(range_)
+        if induced_typ.repr is None and induced_typ.base is None:
+            return None
+        for typ in TYPES:
+            # types always inherit from a single type, and that type is their base
+            # our range can match it with repr or base
+            typ_base = typ.__mro__[1].__name__
+            if typ_base == induced_typ.base:
+                return typ
+
     @abc.abstractmethod
     def map_custom_default_values(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition) -> (bool, str):
         """

linkml-1.8.5/linkml/generators/common/naming.py

@@ -0,0 +1,106 @@
+import logging
+import re
+import unicodedata
+from enum import Enum
+
+
+class NamingProfiles(str, Enum):
+    # GraphQL naming profile ensures compatibility with the GraphQL specification
+    # WRT names: https://spec.graphql.org/October2021/#Name
+    graphql = "graphql"
+
+
+class NameCompatibility(object):
+    """Make a name compatible to the given profile"""
+
+    # heading double underscores and digit reserved to names starting with a digit
+    re_reserved_heading_digit = re.compile("^__[0-9]")
+    # valid name between double underscores is reserved for unicode name transformations
+    re_reserved_unicode_name_transformation = re.compile("__[0-9a-zA-Z][0-9a-zA-Z_]*__")
+    # something like '__U_xxxx_' is reserved for unicode code transformations
+    re_reserved_unicode_code_transformation = re.compile("__U_[0-9a-eA-E]{4}_")
+    # strings starting with a digit
+    re_heading_digit = re.compile("^[0-9]")
+    # character that is neither alphanumeric nor underscore
+    re_no_alphanum_underscore = re.compile("[^0-9a-zA-Z_]")
+
+    def __init__(self, profile: NamingProfiles, do_not_fix: bool = False):
+        """Specify the naming policy on instantiation"""
+        self.profile = profile
+        self.do_not_fix = do_not_fix
+
+    def _no_heading_digits(self, input: str) -> str:
+        """Ensure name does not start with a heading digit"""
+        output = input
+        if self.re_heading_digit.match(input):
+            if self.do_not_fix:
+                raise ValueError(f"Name '{input}' starts with digit (illegal GraphQL) and will not be fixed!")
+            else:
+                logging.warning(
+                    f"Name '{input}' starts with digit (illegal GraphQL), "
+                    + f"it has been prefixed with '__', resulting in {output}"
+                )
+            output = f"__{input}"
+        return output
+
+    def _transform_char(self, char: str) -> str:
+        """Transform unsupported characters"""
+        if len(char) != 1:
+            raise Exception(f"Single character expected, but got '{char}'!!")
+        # replace whitespaces with underscores
+        # the transformation cannot be inverted, but is a well-established
+        # and expected transformation
+        if char == " ":
+            return "_"
+        # try to use names for ASCII characters
+        if ord(char) < 128:
+            try:
+                # unicodedata.lookup should be able to invert the transformation
+                return f"__{unicodedata.name(char).replace(' ', '_').replace('-', '_')}__"
+            except ValueError:
+                pass
+        # fallback to code-transformation if none of the previous has worked
+        return f"__U_{ord(char):04X}_"
+
+    def _only_alphanum_underscore(self, input: str) -> str:
+        """Ensure name does not contain any unsupported characters"""
+        output = input
+        # with re.split and re.findall we get in the same order and separated in two arrays
+        # the substrings between special characters and the special characters
+        no_alphanum_underscore_match = self.re_no_alphanum_underscore.findall(input)
+        if no_alphanum_underscore_match:
+            if self.do_not_fix:
+                raise ValueError(f"Name '{input}' contains a character illegal in GraphQL and will not be fixed!")
+            else:
+                logging.warning(
+                    f"Name '{input}' contains a character illegal in GraphQL, "
+                    + f"the resulting encoded name is {output}"
+                )
+            to_keep = self.re_no_alphanum_underscore.split(input)
+            # first comes first substring to keep
+            output = to_keep[0]
+            # each char replacement is followed by the next substring to keep
+            for offset in range(0, len(to_keep) - 1):
+                output = output + self._transform_char(no_alphanum_underscore_match[offset])
+                output = output + to_keep[offset + 1]
+        return output
+
+    def _graphql_compatibility(self, input: str) -> str:
+        """Ensure name compatibility with GraphQL name policies"""
+        # as of now, some (hopefully) very rare patterns are reserved to mark transformations
+        if self.re_reserved_heading_digit.match(input):
+            raise NotImplementedError("Names starting with a double underscore followed by a digit are not supported!!")
+        if self.re_reserved_unicode_name_transformation.match(input):
+            raise NotImplementedError("Names containing valid names between double underscores are not supported!!")
+        if self.re_reserved_unicode_code_transformation.match(input):
+            raise NotImplementedError("Names containing strings like '__U_xxxx_' are not supported!!")
+        # apply transformation
+        output = input
+        output = self._no_heading_digits(output)
+        output = self._only_alphanum_underscore(output)
+        return output
+
+    def compatible(self, input: str) -> str:
+        """Make given name compatible with the given naming policy."""
+        if self.profile == "graphql":
+            return self._graphql_compatibility(input)

{linkml-1.8.3 → linkml-1.8.5}/linkml/generators/docgen/index.md.jinja2

@@ -21,11 +21,11 @@ Name: {{ schema.name }}
 | --- | --- |
 {% if gen.hierarchical_class_view -%}
 {% for u, v in gen.class_hierarchy_as_tuples() -%}
-| {{ " "|safe*u*8 }}{{ gen.link(schemaview.get_class(v)) }} | {{ schemaview.get_class(v).description }} |
+| {{ " "|safe*u*8 }}{{ gen.link(schemaview.get_class(v), True) }} | {{ schemaview.get_class(v).description }} |
 {% endfor %}
 {% else -%}
 {% for c in gen.all_class_objects()|sort(attribute=sort_by) -%}
-| {{gen.link(c)}} | {{c.description|enshorten}} |
+| {{gen.link(c, True)}} | {{c.description|enshorten}} |
 {% endfor %}
 {% endif %}
 
@@ -34,7 +34,7 @@ Name: {{ schema.name }}
 | Slot | Description |
 | --- | --- |
 {% for s in gen.all_slot_objects()|sort(attribute=sort_by) -%}
-| {{gen.link(s)}} | {{s.description|enshorten}} |
+| {{gen.link(s, True)}} | {{s.description|enshorten}} |
 {% endfor %}
 
 ## Enumerations
@@ -42,7 +42,7 @@ Name: {{ schema.name }}
 | Enumeration | Description |
 | --- | --- |
 {% for e in gen.all_enum_objects()|sort(attribute=sort_by) -%}
-| {{gen.link(e)}} | {{e.description|enshorten}} |
+| {{gen.link(e, True)}} | {{e.description|enshorten}} |
 {% endfor %}
 
 ## Types
@@ -50,7 +50,7 @@ Name: {{ schema.name }}
 | Type | Description |
 | --- | --- |
 {% for t in gen.all_type_objects()|sort(attribute=sort_by) -%}
-| {{gen.link(t)}} | {{t.description|enshorten}} |
+| {{gen.link(t, True)}} | {{t.description|enshorten}} |
 {% endfor %}
 
 ## Subsets
@@ -58,5 +58,5 @@ Name: {{ schema.name }}
 | Subset | Description |
 | --- | --- |
 {% for ss in schemaview.all_subsets().values()|sort(attribute='name') -%}
-| {{gen.link(ss)}} | {{ss.description|enshorten}} |
+| {{gen.link(ss, True)}} | {{ss.description|enshorten}} |
 {% endfor %}

{linkml-1.8.3 → linkml-1.8.5}/linkml/generators/docgen.py

@@ -50,6 +50,13 @@ DIALECT = MarkdownDialect
 MAX_CHARS_IN_TABLE = 80
 MAX_RANK = 1000
 
+SCHEMA_SUBFOLDER = "schemas"
+CLASS_SUBFOLDER = "classes"
+SLOT_SUBFOLDER = "slots"
+ENUM_SUBFOLDER = "enums"
+TYPE_SUBFOLDER = "types"
+SUBSET_SUBFOLDER = "subsets"
+
 
 def enshorten(input):
     """
@@ -144,6 +151,9 @@ class DocGenerator(Generator):
     include_top_level_diagram: bool = False
     """Whether the index page should include a schema diagram"""
 
+    subfolder_type_separation: bool = False
+    """Whether each type (class, slot, etc.) should be put in separate subfolder for navigation purposes"""
+
     example_directory: Optional[str] = None
     example_runner: ExampleRunner = field(default_factory=lambda: ExampleRunner())
 
@@ -154,6 +164,7 @@ class DocGenerator(Generator):
     use_slot_uris: bool = False
     use_class_uris: bool = False
     hierarchical_class_view: bool = False
+    render_imports: bool = False
 
     def __post_init__(self):
         dialect = self.dialect
@@ -205,7 +216,11 @@ class DocGenerator(Generator):
             self.logger.debug(f"  Generating doc for {schema_name}")
             imported_schema = sv.schema_map.get(schema_name)
             out_str = template.render(gen=self, schema=imported_schema, schemaview=sv, **template_vars)
-            self._write(out_str, directory, imported_schema.name)
+            self._write(
+                out_str,
+                f"{directory}/{SCHEMA_SUBFOLDER}" if self.subfolder_type_separation else directory,
+                imported_schema.name,
+            )
         self.logger.debug("Processing Classes...")
         template = self._get_template("class")
         for cn, c in sv.all_classes().items():
@@ -214,7 +229,7 @@ class DocGenerator(Generator):
             n = self.name(c)
             self.logger.debug(f"  Generating doc for {n}")
             out_str = template.render(gen=self, element=c, schemaview=sv, **template_vars)
-            self._write(out_str, directory, n)
+            self._write(out_str, f"{directory}/{CLASS_SUBFOLDER}" if self.subfolder_type_separation else directory, n)
         self.logger.debug("Processing Slots...")
         template = self._get_template("slot")
         for sn, s in sv.all_slots().items():
@@ -224,7 +239,7 @@ class DocGenerator(Generator):
             self.logger.debug(f"  Generating doc for {n}")
             s = sv.induced_slot(sn)
             out_str = template.render(gen=self, element=s, schemaview=sv, **template_vars)
-            self._write(out_str, directory, n)
+            self._write(out_str, f"{directory}/{SLOT_SUBFOLDER}" if self.subfolder_type_separation else directory, n)
         self.logger.debug("Processing Enums...")
         template = self._get_template("enum")
         for en, e in sv.all_enums().items():
@@ -233,7 +248,7 @@ class DocGenerator(Generator):
             n = self.name(e)
             self.logger.debug(f"  Generating doc for {n}")
             out_str = template.render(gen=self, element=e, schemaview=sv, **template_vars)
-            self._write(out_str, directory, n)
+            self._write(out_str, f"{directory}/{ENUM_SUBFOLDER}" if self.subfolder_type_separation else directory, n)
         self.logger.debug("Processing Types...")
         template = self._get_template("type")
         for tn, t in sv.all_types().items():
@@ -243,7 +258,7 @@ class DocGenerator(Generator):
             self.logger.debug(f"  Generating doc for {n}")
             t = sv.induced_type(tn)
             out_str = template.render(gen=self, element=t, schemaview=sv, **template_vars)
-            self._write(out_str, directory, n)
+            self._write(out_str, f"{directory}/{TYPE_SUBFOLDER}" if self.subfolder_type_separation else directory, n)
         self.logger.debug("Processing Subsets...")
         template = self._get_template("subset")
         for _, s in sv.all_subsets().items():
@@ -252,7 +267,7 @@ class DocGenerator(Generator):
             n = self.name(s)
             self.logger.debug(f"  Generating doc for {n}")
             out_str = template.render(gen=self, element=s, schemaview=sv, **template_vars)
-            self._write(out_str, directory, n)
+            self._write(out_str, f"{directory}/{SUBSET_SUBFOLDER}" if self.subfolder_type_separation else directory, n)
 
     def _write(self, out_str: str, directory: str, name: str) -> None:
         """
@@ -384,13 +399,19 @@ class DocGenerator(Generator):
         curie = self.uri(element, expand=False)
         return f"[{curie}]({uri})"
 
-    def link(self, e: Union[Definition, DefinitionName]) -> str:
+    def link(self, e: Union[Definition, DefinitionName], index_link: bool = False) -> str:
         """
         Render an element as a hyperlink
 
         :param e:
+        :param index_link: Whether this is a link for the index page or not
         :return:
         """
+        if index_link:
+            subfolder = ""
+        else:
+            subfolder = "../"
+
         if e is None:
             return "NONE"
         if not isinstance(e, Definition):
@@ -401,20 +422,43 @@ class DocGenerator(Generator):
             if self.use_class_uris:
                 curie = self.schemaview.get_uri(e)
                 if curie is not None:
-                    return self._markdown_link(n=curie.split(":")[1], name=e.name)
-            return self._markdown_link(camelcase(e.name))
+                    return self._markdown_link(
+                        n=curie.split(":")[1],
+                        name=e.name,
+                        subfolder=subfolder + CLASS_SUBFOLDER if self.subfolder_type_separation else None,
+                    )
+            return self._markdown_link(
+                camelcase(e.name),
+                subfolder=subfolder + CLASS_SUBFOLDER if self.subfolder_type_separation else None,
+            )
         elif isinstance(e, EnumDefinition):
-            return self._markdown_link(camelcase(e.name))
+            return self._markdown_link(
+                camelcase(e.name),
+                subfolder=subfolder + ENUM_SUBFOLDER if self.subfolder_type_separation else None,
+            )
         elif isinstance(e, SlotDefinition):
             if self.use_slot_uris:
                 curie = self.schemaview.get_uri(e)
                 if curie is not None:
-                    return self._markdown_link(n=curie.split(":")[1], name=e.name)
-            return self._markdown_link(underscore(e.name))
+                    return self._markdown_link(
+                        n=curie.split(":")[1],
+                        name=e.name,
+                        subfolder=subfolder + SLOT_SUBFOLDER if self.subfolder_type_separation else None,
+                    )
+            return self._markdown_link(
+                underscore(e.name),
+                subfolder=subfolder + SLOT_SUBFOLDER if self.subfolder_type_separation else None,
+            )
         elif isinstance(e, TypeDefinition):
-            return self._markdown_link(camelcase(e.name))
+            return self._markdown_link(
+                camelcase(e.name),
+                subfolder=subfolder + TYPE_SUBFOLDER if self.subfolder_type_separation else None,
+            )
         elif isinstance(e, SubsetDefinition):
-            return self._markdown_link(camelcase(e.name))
+            return self._markdown_link(
+                camelcase(e.name),
+                subfolder=subfolder + SUBSET_SUBFOLDER if self.subfolder_type_separation else None,
+            )
         else:
             return e.name
 
@@ -716,7 +760,7 @@ class DocGenerator(Generator):
         Ensures rank is non-null
         :return: iterator
         """
-        elts = self.schemaview.all_classes(imports=self.mergeimports).values()
+        elts = self.schemaview.all_classes(imports=self.render_imports).values()
         _ensure_ranked(elts)
         for e in elts:
             yield e
@@ -728,7 +772,7 @@ class DocGenerator(Generator):
         Ensures rank is non-null
         :return: iterator
         """
-        elts = self.schemaview.all_slots(imports=self.mergeimports).values()
+        elts = self.schemaview.all_slots(imports=self.render_imports).values()
         _ensure_ranked(elts)
         for e in elts:
             yield e
@@ -740,7 +784,7 @@ class DocGenerator(Generator):
         Ensures rank is non-null
         :return: iterator
         """
-        elts = self.schemaview.all_types(imports=self.mergeimports).values()
+        elts = self.schemaview.all_types(imports=self.render_imports).values()
         _ensure_ranked(elts)
         for e in elts:
             yield e
@@ -755,7 +799,7 @@ class DocGenerator(Generator):
         Ensures rank is non-null
         :return: iterator
         """
-        elts = self.schemaview.all_enums(imports=self.mergeimports).values()
+        elts = self.schemaview.all_enums(imports=self.render_imports).values()
         _ensure_ranked(elts)
         for e in elts:
             yield e
@@ -767,7 +811,7 @@ class DocGenerator(Generator):
         Ensures rank is non-null
         :return: iterator
         """
-        elts = self.schemaview.all_subsets(imports=self.mergeimports).values()
+        elts = self.schemaview.all_subsets(imports=self.render_imports).values()
         _ensure_ranked(elts)
         for e in elts:
             yield e
@@ -791,7 +835,7 @@ class DocGenerator(Generator):
         :return: tuples (depth: int, cls: ClassDefinitionName)
         """
         sv = self.schemaview
-        roots = sv.class_roots(mixins=False, imports=self.mergeimports)
+        roots = sv.class_roots(mixins=False, imports=self.render_imports)
 
         # by default the classes are sorted alphabetically
         roots = sorted(roots, key=str.casefold, reverse=True)
@@ -805,7 +849,7 @@ class DocGenerator(Generator):
             depth, class_name = stack.pop()
             yield depth, class_name
             children = sorted(
-                sv.class_children(class_name=class_name, mixins=False, imports=self.mergeimports),
+                sv.class_children(class_name=class_name, mixins=False, imports=self.render_imports),
                 key=str.casefold,
                 reverse=True,
             )
@@ -965,6 +1009,12 @@ class DocGenerator(Generator):
     default=True,
     help="Render class table on index page in a hierarchically indented view",
 )
+@click.option(
+    "--render-imports/--no-render-imports",
+    default=False,
+    show_default=True,
+    help="Render also the documentation of elements from imported schemas",
+)
 @click.option(
     "--example-directory",
     help="Folder in which example files are found. These are used to make inline examples",
@@ -977,6 +1027,11 @@ Include LinkML Schema outside of imports mechanism.  Helpful in including deprec
 YAML, and including it when necessary but not by default (e.g. in documentation or for backwards compatibility)
 """,
 )
+@click.option(
+    "--subfolder-type-separation/--no-subfolder-type-separation",
+    default=False,
+    help="Separate type (class, slot, etc.) outputs in different subfolders for navigation purposes",
+)
 @click.version_option(__version__, "-V", "--version")
 @click.command(name="doc")
 def cli(
@@ -988,6 +1043,8 @@ def cli(
     use_slot_uris,
     use_class_uris,
     hierarchical_class_view,
+    subfolder_type_separation,
+    render_imports,
     **args,
 ):
     """Generate documentation folder from a LinkML YAML schema
@@ -1018,6 +1075,8 @@ def cli(
         use_class_uris=use_class_uris,
         hierarchical_class_view=hierarchical_class_view,
         index_name=index_name,
+        subfolder_type_separation=subfolder_type_separation,
+        render_imports=render_imports,
         **args,
     )
     print(gen.serialize())