linkml 1.8.2__tar.gz → 1.8.4__tar.gz

{linkml-1.8.2 → linkml-1.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.8.2
+Version: 1.8.4
 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.2 → linkml-1.8.4}/linkml/cli/main.py

@@ -6,6 +6,7 @@ Gathers all the other linkml click entrypoints and puts them under ``linkml`` :)
 
 import click
 
+from linkml._version import __version__
 from linkml.generators.csvgen import cli as gen_csv
 from linkml.generators.docgen import cli as gen_doc
 from linkml.generators.dotgen import cli as gen_graphviz
@@ -54,6 +55,7 @@ from linkml.workspaces.example_runner import cli as linkml_run_examples
 
 
 @click.group()
+@click.version_option(__version__, "-V", "--version")
 def linkml():
     """
     LinkML: A flexible linked data modeling language
@@ -61,6 +63,7 @@ def linkml():
 
 
 @linkml.group()
+@click.version_option(__version__, "-V", "--version")
 def generate():
     """
     Generate formats from a LinkML schema
@@ -68,6 +71,7 @@ def generate():
 
 
 @linkml.group()
+@click.version_option(__version__, "-V", "--version")
 def dev():
     """
     Helper tools for linkml development

{linkml-1.8.2 → linkml-1.8.4}/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.4/linkml/generators/common/ifabsent_processor.py

@@ -0,0 +1,286 @@
+import abc
+import re
+from abc import ABC
+from typing import Any, Optional
+
+from linkml_runtime import SchemaView
+from linkml_runtime.linkml_model import (
+    Boolean,
+    ClassDefinition,
+    Date,
+    Datetime,
+    Decimal,
+    Double,
+    EnumDefinitionName,
+    Float,
+    Integer,
+    SlotDefinition,
+    String,
+    Time,
+    Uri,
+)
+from linkml_runtime.linkml_model.types import (
+    Curie,
+    DateOrDatetime,
+    Jsonpath,
+    Jsonpointer,
+    Ncname,
+    Nodeidentifier,
+    Objectidentifier,
+    Sparqlpath,
+    Uriorcurie,
+)
+
+
+class IfAbsentProcessor(ABC):
+    """
+    Processes value of ifabsent slot.
+
+    See `<https://w3id.org/linkml/ifabsent>`_.
+    """
+
+    ifabsent_regex = re.compile("""(?:(?P<type>\w+)\()?[\"\']?(?P<default_value>[^\(\)\"\')]*)[\"\']?\)?""")
+
+    def __init__(self, schema_view: SchemaView):
+        self.schema_view = schema_view
+
+    def process_slot(self, slot: SlotDefinition, cls: ClassDefinition) -> Optional[str]:
+        if slot.ifabsent:
+            ifabsent_match = self.ifabsent_regex.search(slot.ifabsent)
+            ifabsent_default_value = ifabsent_match.group("default_value")
+
+            return self._map_to_default_value(slot, ifabsent_default_value, cls)
+
+        return None
+
+    def _map_to_default_value(
+        self, slot: SlotDefinition, ifabsent_default_value: Any, cls: ClassDefinition
+    ) -> Optional[str]:
+        # Used to manage specific cases that aren't generic
+        mapped, custom_default_value = self.map_custom_default_values(ifabsent_default_value, slot, cls)
+        if mapped:
+            return custom_default_value
+
+        if slot.range == String.type_name:
+            return self.map_string_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Boolean.type_name:
+            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):
+                return self.map_boolean_false_default_value(slot, cls)
+            else:
+                raise ValueError(
+                    f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot does not match a valid boolean "
+                    f"value"
+                )
+
+        if slot.range == Integer.type_name:
+            return self.map_integer_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Float.type_name:
+            return self.map_float_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Double.type_name:
+            return self.map_double_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Decimal.type_name:
+            return self.map_decimal_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Time.type_name:
+            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)
+            else:
+                raise ValueError(
+                    f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot does not match a valid time value"
+                )
+
+        # TODO manage timezones and offsets
+        if slot.range == Date.type_name:
+            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)
+            else:
+                raise ValueError(
+                    f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot does not match a valid date value"
+                )
+
+        # TODO manage timezones and offsets
+        if slot.range == Datetime.type_name:
+            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(
+                    match[1], match[2], match[3], match[4], match[5], match[6], slot, cls
+                )
+            else:
+                raise ValueError(
+                    f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot does not match a valid datetime "
+                    f"value"
+                )
+
+        # TODO manage timezones and offsets
+        if slot.range == DateOrDatetime.type_name:
+            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)
+            elif match:
+                return self.map_datetime_default_value(
+                    match[1], match[2], match[3], match[4], match[5], match[6], slot, cls
+                )
+            else:
+                raise ValueError(
+                    f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot does not match a valid date or "
+                    f"datetime value"
+                )
+
+        if slot.range == Uri.type_name:
+            return self.map_uri_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Curie.type_name:
+            return self.map_curie_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Uriorcurie.type_name:
+            return self.map_uri_or_curie_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Ncname.type_name:
+            return self.map_nc_name_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Objectidentifier.type_name:
+            return self.map_object_identifier_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Nodeidentifier.type_name:
+            return self.map_node_identifier_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Jsonpointer.type_name:
+            return self.map_json_pointer_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Jsonpath.type_name:
+            return self.map_json_path_default_value(ifabsent_default_value, slot, cls)
+
+        if slot.range == Sparqlpath.type_name:
+            return self.map_sparql_path_default_value(ifabsent_default_value, slot, cls)
+
+        # -----------------------
+        #    Enum slot ranges
+        # -----------------------
+
+        for enum_name, enum in self.schema_view.all_enums().items():
+            if enum_name == slot.range:
+                for permissible_value_name, permissible_value in enum.permissible_values.items():
+                    if permissible_value_name == ifabsent_default_value:
+                        return self.map_enum_default_value(enum_name, permissible_value_name, slot, cls)
+
+        raise ValueError(f"The ifabsent value `{slot.ifabsent}` of the `{slot.name}` slot could not be processed")
+
+    @abc.abstractmethod
+    def map_custom_default_values(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition) -> (bool, str):
+        """
+        Maps custom default values that aren't generic behaviours.
+
+        @param default_value: the default value extracted from the ifabsent attribute
+        @param slot: the definition of the slot
+        @param cls: the definition of the class
+        @return: a boolean that indicates if the value has been mapped followed by the mapped value
+        """
+        return False, None
+
+    @abc.abstractmethod
+    def map_string_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_integer_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_boolean_true_default_value(self, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_boolean_false_default_value(self, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_float_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_double_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_decimal_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_time_default_value(self, hour: str, minutes: str, seconds: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_date_default_value(self, year: str, month: str, day: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_datetime_default_value(
+        self,
+        year: str,
+        month: str,
+        day: str,
+        hour: str,
+        minutes: str,
+        seconds: str,
+        slot: SlotDefinition,
+        cls: ClassDefinition,
+    ):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_uri_or_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_curie_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_uri_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_nc_name_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_object_identifier_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_node_identifier_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_json_pointer_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_json_path_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_sparql_path_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def map_enum_default_value(
+        self, enum_name: EnumDefinitionName, permissible_value_name: str, slot: SlotDefinition, cls: ClassDefinition
+    ):
+        raise NotImplementedError()
+
+    def _uri_for(self, s: str) -> str:
+        uri = str(self.schema_view.namespaces().uri_for(s))
+        return self.schema_view.namespaces().curie_for(uri, True, True) or self._strval(uri)
+
+    def _strval(self, txt: str) -> str:
+        txt = str(txt).replace('"', '\\"')
+        return f'"{txt}"'

{linkml-1.8.2 → linkml-1.8.4}/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.2 → linkml-1.8.4}/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())
 
@@ -205,7 +215,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 +228,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 +238,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 +247,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 +257,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 +266,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 +398,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 +421,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
 
@@ -977,6 +1020,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 +1036,7 @@ def cli(
     use_slot_uris,
     use_class_uris,
     hierarchical_class_view,
+    subfolder_type_separation,
     **args,
 ):
     """Generate documentation folder from a LinkML YAML schema
@@ -1018,6 +1067,7 @@ def cli(
         use_class_uris=use_class_uris,
         hierarchical_class_view=hierarchical_class_view,
         index_name=index_name,
+        subfolder_type_separation=subfolder_type_separation,
         **args,
     )
     print(gen.serialize())

{linkml-1.8.2 → linkml-1.8.4}/linkml/generators/golanggen.py

@@ -11,6 +11,8 @@ from linkml_runtime.utils.formatutils import camelcase, underscore
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
 
+logger = logging.getLogger(__name__)
+
 type_map = {
     "str": "string",
     "int": "int",
@@ -175,7 +177,7 @@ class GolangGenerator(Generator):
                 if t.base and t.base in type_map:
                     return type_map[t.base]
                 else:
-                    logging.warning(f"Unknown type.base: {t.name}")
+                    logger.warning(f"Unknown type.base: {t.name}")
             return "string"
 
     @staticmethod

{linkml-1.8.2 → linkml-1.8.4}/linkml/generators/jsonldcontextgen.py

@@ -21,7 +21,6 @@ from linkml.utils.generator import Generator, shared_arguments
 URI_RANGES = (SHEX.nonliteral, SHEX.bnode, SHEX.iri)
 
 ENUM_CONTEXT = {
-    "@vocab": "@null",
     "text": "skos:notation",
     "description": "skos:prefLabel",
     "meaning": "@id",

{linkml-1.8.2 → linkml-1.8.4}/linkml/generators/jsonschemagen.py

@@ -24,6 +24,8 @@ from linkml._version import __version__
 from linkml.generators.common.type_designators import get_type_designator_value
 from linkml.utils.generator import Generator, shared_arguments
 
+logger = logging.getLogger(__name__)
+
 # Map from underlying python data type to json equivalent
 # Note: The underlying types are a union of any built-in python datatype + any type defined in
 #       linkml-runtime/utils/metamodelcore.py
@@ -222,14 +224,14 @@ class JsonSchemaGenerator(Generator):
 
     def __post_init__(self):
         if self.topClass:
-            logging.warning("topClass is deprecated - use top_class")
+            logger.warning("topClass is deprecated - use top_class")
             self.top_class = self.topClass
 
         super().__post_init__()
 
         if self.top_class:
             if self.schemaview.get_class(self.top_class) is None:
-                logging.warning(f"No class in schema named {self.top_class}")
+                logger.warning(f"No class in schema named {self.top_class}")
 
     def start_schema(self, inline: bool = False) -> JsonSchema:
         self.inline = inline