linkml 1.8.1__tar.gz → 1.8.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.8.1
+Version: 1.8.2
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink
@@ -36,7 +36,7 @@ Requires-Dist: jinja2 (>=3.1.0)
 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.0)
+Requires-Dist: linkml-runtime (>=1.8.1,<2.0.0)
 Requires-Dist: openpyxl
 Requires-Dist: parse
 Requires-Dist: prefixcommons (>=0.1.7)

linkml-1.8.2/linkml/cli/__main__.py

@@ -0,0 +1,4 @@
+from linkml.cli.main import linkml as cli
+
+if __name__ == "__main__":
+    cli()

linkml-1.8.2/linkml/cli/main.py

@@ -0,0 +1,126 @@
+"""
+Main ``linkml`` entrypoint
+
+Gathers all the other linkml click entrypoints and puts them under ``linkml`` :)
+"""
+
+import click
+
+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
+from linkml.generators.erdiagramgen import cli as gen_erdiagram
+from linkml.generators.excelgen import cli as gen_excel
+from linkml.generators.golanggen import cli as gen_golang
+from linkml.generators.golrgen import cli as gen_golr_views
+from linkml.generators.graphqlgen import cli as gen_graphql
+from linkml.generators.javagen import cli as gen_java
+from linkml.generators.jsonldcontextgen import cli as gen_jsonld_context
+from linkml.generators.jsonldgen import cli as gen_jsonld
+from linkml.generators.jsonschemagen import cli as gen_json_schema
+from linkml.generators.linkmlgen import cli as gen_linkml
+from linkml.generators.markdowngen import cli as gen_markdown
+from linkml.generators.namespacegen import cli as gen_namespaces
+from linkml.generators.owlgen import cli as gen_owl
+from linkml.generators.plantumlgen import cli as gen_plantuml
+from linkml.generators.prefixmapgen import cli as gen_prefix_map
+from linkml.generators.projectgen import cli as gen_project
+from linkml.generators.protogen import cli as gen_proto
+from linkml.generators.pydanticgen import cli as gen_pydantic
+from linkml.generators.pythongen import cli as gen_python
+from linkml.generators.rdfgen import cli as gen_rdf
+from linkml.generators.shaclgen import cli as gen_shacl
+from linkml.generators.shexgen import cli as gen_shex
+from linkml.generators.sparqlgen import cli as gen_sparql
+from linkml.generators.sqlalchemygen import cli as gen_sqla
+from linkml.generators.sqltablegen import cli as gen_sqltables
+from linkml.generators.sssomgen import cli as gen_sssom
+from linkml.generators.summarygen import cli as gen_summary
+from linkml.generators.terminusdbgen import cli as gen_terminusdb
+from linkml.generators.typescriptgen import cli as gen_typescript
+from linkml.generators.yamlgen import cli as gen_yaml
+from linkml.generators.yumlgen import cli as gen_yuml
+from linkml.linter.cli import main as linkml_lint
+from linkml.utils.converter import cli as linkml_convert
+from linkml.utils.execute_tutorial import cli as run_tutorial
+from linkml.utils.schema_fixer import main as linkml_schema_fixer
+from linkml.utils.sqlutils import main as linkml_sqldb
+from linkml.validator.cli import cli as linkml_validate
+from linkml.workspaces.example_runner import cli as linkml_run_examples
+
+# --------------------------------------------------
+# Command groups
+# --------------------------------------------------
+
+
+@click.group()
+def linkml():
+    """
+    LinkML: A flexible linked data modeling language
+    """
+
+
+@linkml.group()
+def generate():
+    """
+    Generate formats from a LinkML schema
+    """
+
+
+@linkml.group()
+def dev():
+    """
+    Helper tools for linkml development
+    """
+
+
+# --------------------------------------------------
+# Add commands to groups
+# --------------------------------------------------
+
+# Top-level linkml commands
+linkml.add_command(linkml_convert, name="convert")
+linkml.add_command(linkml_lint, name="lint")
+linkml.add_command(linkml_sqldb, name="sqldb")
+linkml.add_command(linkml_schema_fixer, name="fix")
+linkml.add_command(linkml_run_examples, name="examples")
+linkml.add_command(linkml_validate, name="validate")
+
+# Generators
+generate.add_command(gen_jsonld_context, name="jsonld-context")
+generate.add_command(gen_prefix_map, name="prefix-map")
+generate.add_command(gen_csv, name="csv")
+generate.add_command(gen_graphviz, name="graphviz")
+generate.add_command(gen_golang, name="golang")
+generate.add_command(gen_golr_views, name="golr-views")
+generate.add_command(gen_graphql, name="graphql")
+generate.add_command(gen_java, name="java")
+generate.add_command(gen_jsonld, name="jsonld")
+generate.add_command(gen_json_schema, name="json-schema")
+generate.add_command(gen_markdown, name="markdown")
+generate.add_command(gen_doc, name="doc")
+generate.add_command(gen_namespaces, name="namespaces")
+generate.add_command(gen_owl, name="owl")
+generate.add_command(gen_plantuml, name="plantuml")
+generate.add_command(gen_proto, name="proto")
+generate.add_command(gen_python, name="python")
+generate.add_command(gen_pydantic, name="pydantic")
+generate.add_command(gen_rdf, name="rdf")
+generate.add_command(gen_shex, name="shex")
+generate.add_command(gen_shacl, name="shacl")
+generate.add_command(gen_sparql, name="sparql")
+generate.add_command(gen_typescript, name="typescript")
+generate.add_command(gen_terminusdb, name="terminusdb")
+generate.add_command(gen_yuml, name="yuml")
+generate.add_command(gen_yaml, name="yaml")
+generate.add_command(gen_erdiagram, name="erdiagram")
+generate.add_command(gen_sqla, name="sqla")
+generate.add_command(gen_sqltables, name="sqltables")
+generate.add_command(gen_summary, name="summary")
+generate.add_command(gen_project, name="project")
+generate.add_command(gen_excel, name="excel")
+generate.add_command(gen_sssom, name="sssom")
+generate.add_command(gen_linkml, name="linkml")
+
+# Dev helpers
+dev.add_command(run_tutorial, name="tutorial")

linkml-1.8.2/linkml/generators/common/build.py

@@ -0,0 +1,105 @@
+"""
+Models for intermediate build results
+
+(see PydanticGenerator for example implementation and use)
+"""
+
+import dataclasses
+from abc import abstractmethod
+from typing import Any, TypeVar
+
+try:
+    from typing import Annotated
+except ImportError:
+    from typing_extensions import Annotated
+
+
+from linkml_runtime.linkml_model import (
+    ClassDefinition,
+    EnumDefinition,
+    SchemaDefinition,
+    SlotDefinition,
+    TypeDefinition,
+)
+from pydantic import BaseModel, ConfigDict, GetCoreSchemaHandler
+from pydantic_core import core_schema
+
+T = TypeVar("T", bound="BuildResult", covariant=True)
+
+
+@dataclasses.dataclass()
+class SkipValidation:
+    """
+    A version of :class:`pydantic.SkipValidation` that actually skips generating the
+    schema for the field entirely - useful for including types that don't need to be validated
+    like the metamodel dataclasses
+    """
+
+    def __class_getitem__(cls, item: Any) -> Any:
+        return Annotated[item, SkipValidation()]
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source: Any, handler: GetCoreSchemaHandler) -> core_schema.CoreSchema:
+        return core_schema.any_schema()
+
+    __hash__ = object.__hash__
+
+
+class BuildResult(BaseModel):
+    """
+    The result of any build phase for any linkML object
+
+    BuildResults are merged in the serialization process, and are used
+    to keep track of not only the particular representation
+    of the thing in question, but any "side effects" that need to happen
+    elsewhere in the generation process (like adding imports, injecting classes, etc.)
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @abstractmethod
+    def merge(self, other: T) -> T:
+        """
+        Build results should have some means of merging results of a like kind
+        """
+
+
+class SchemaResult(BuildResult):
+    """Abstract results container for built schemas"""
+
+    source: SkipValidation[SchemaDefinition]
+
+    def merge(self, other: T) -> T:
+        """
+        SchemaResults are special and don't need a merge method, since generating
+        multiple schemas at once is not common or expected behavior for a generator.
+        """
+        raise NotImplementedError("SchemaResult doesn't need a merge method, and none has been defined")
+
+
+class ClassResult(BuildResult):
+    """Abstract results container for built classes"""
+
+    source: SkipValidation[ClassDefinition]
+
+
+class SlotResult(BuildResult):
+    """Abstract results container for built slots"""
+
+    source: SkipValidation[SlotDefinition]
+
+
+class TypeResult(BuildResult):
+    """Abstract results container for built types"""
+
+    source: SkipValidation[TypeDefinition]
+
+
+class EnumResult(BuildResult):
+    """Abstract results container for built enums"""
+
+    source: SkipValidation[EnumDefinition]
+
+
+class RangeResult(BuildResult):
+    """Abstract results container for just the range part of a slot"""

linkml-1.8.2/linkml/generators/common/lifecycle.py

@@ -0,0 +1,124 @@
+"""
+Lifestyle methods mixin
+"""
+
+from typing import Iterable, TypeVar
+
+from linkml_runtime import SchemaView
+from linkml_runtime.linkml_model.meta import (
+    ClassDefinition,
+    EnumDefinition,
+    SchemaDefinition,
+    SlotDefinition,
+    TypeDefinition,
+)
+
+from linkml.generators.common.build import ClassResult, RangeResult, SchemaResult, SlotResult, TypeResult
+from linkml.generators.common.template import TemplateModel
+
+TSchema = TypeVar("TSchema", bound=SchemaResult)
+TClass = TypeVar("TClass", bound=ClassResult)
+TSlot = TypeVar("TSlot", bound=SlotResult)
+TRange = TypeVar("TRange", bound=RangeResult)
+TType = TypeVar("TType", bound=TypeResult)
+TEnum = TypeVar("TEnum", bound=EnumDefinition)
+TTemplate = TypeVar("TTemplate", bound=TemplateModel)
+
+
+class LifecycleMixin:
+    """
+    Mixin class for implementing lifecycle methods to modify the generation process
+    without needing messy overrides and tiptoeing around parent generator classes.
+
+    Not all classes that inherit from the mixin will be able to implement all of the lifecycle methods.
+    The generator class should make it clear which methods are supported in its documentation -
+    no programmatic checking for lifecycle method support is available on first implementation.
+
+    Generators should **not** define any of the lifecycle methods themselves - the purpose is
+    to allow downstream modification of the generation process with clear entrypoints and without
+    needing to copy/paste code from the generator/call ``super()`` methods - if the Generator
+    is also using the lifecycle method, the point of the mixin is lost.
+
+    The order that these methods are called may vary in different generators, but in general, if
+    slots are generated hierarchically within classes as in the pydantic generator...
+
+    * :meth:`.before_generate_schema`
+    * :meth:`.before_generate_classes`
+    * :meth:`.before_generate_class`
+    * :meth:`.before_generate_slots`
+    * :meth:`.before_generate_slot`
+    * :meth:`.after_generate_slot`
+    * :meth:`.after_generate_slots`
+    * :meth:`.after_generate_class`
+    * :meth:`.after_generate_classes`
+    * :meth:`.after_generate_schema`
+    * :meth:`.before_render_template`
+    * :meth:`.after_render_template`
+
+    (Add other examples of ordering from other generators as implemented)
+
+    Each method should receive a :class:`.SchemaView` to get perspective on the current schema
+    being built. The ``before_`` methods should receive and return a single or list of ``Definitions``
+    and the ``after_`` methods should receive and return a single or list of the appropriate :class:`.BuildResult`
+    type.
+    """
+
+    def before_generate_schema(self, schema: SchemaDefinition, sv: SchemaView) -> SchemaDefinition:
+        return schema
+
+    def after_generate_schema(self, schema: TSchema, sv: SchemaView) -> TSchema:
+        return schema
+
+    def before_generate_class(self, cls: ClassDefinition, sv: SchemaView) -> ClassDefinition:
+        return cls
+
+    def after_generate_class(self, cls: TClass, sv: SchemaView) -> TClass:
+        return cls
+
+    def before_generate_classes(self, cls: Iterable[ClassDefinition], sv: SchemaView) -> Iterable[ClassDefinition]:
+        return cls
+
+    def after_generate_classes(self, cls: Iterable[TClass], sv: SchemaView) -> Iterable[TClass]:
+        return cls
+
+    def before_generate_slot(self, slot: SlotDefinition, sv: SchemaView) -> SlotDefinition:
+        return slot
+
+    def after_generate_slot(self, slot: TSlot, sv: SchemaView) -> TSlot:
+        return slot
+
+    def before_generate_slots(self, slot: Iterable[SlotDefinition], sv: SchemaView) -> Iterable[SlotDefinition]:
+        return slot
+
+    def after_generate_slots(self, slot: Iterable[TSlot], sv: SchemaView) -> Iterable[TSlot]:
+        return slot
+
+    def before_generate_type(self, typ: TypeDefinition, sv: SchemaView) -> TypeDefinition:
+        return typ
+
+    def after_generate_type(self, typ: TType, sv: SchemaView) -> TType:
+        return typ
+
+    def before_generate_types(self, typ: Iterable[TypeDefinition], sv: SchemaView) -> Iterable[TypeDefinition]:
+        return typ
+
+    def after_generate_types(self, typ: Iterable[TType], sv: SchemaView) -> Iterable[TType]:
+        return typ
+
+    def before_generate_enum(self, enum: EnumDefinition, sv: SchemaView) -> EnumDefinition:
+        return enum
+
+    def after_generate_enum(self, enum: TEnum, sv: SchemaView) -> TEnum:
+        return enum
+
+    def before_generate_enums(self, enum: Iterable[EnumDefinition], sv: SchemaView) -> Iterable[EnumDefinition]:
+        return enum
+
+    def after_generate_enums(self, enum: Iterable[TEnum], sv: SchemaView) -> Iterable[TEnum]:
+        return enum
+
+    def before_render_template(self, template: TTemplate, sv: SchemaView) -> TTemplate:
+        return template
+
+    def after_render_template(self, template: str, sv: SchemaView) -> str:
+        return template

linkml-1.8.2/linkml/generators/common/template.py

@@ -0,0 +1,89 @@
+"""
+Base classes for jinja template handling classes.
+
+See :mod:`.linkml.generators.pydanticgen.template` for example implementation
+"""
+
+from copy import copy
+from typing import Any, ClassVar, Dict, List, Optional, Union
+
+from jinja2 import Environment
+from pydantic import BaseModel
+
+
+class TemplateModel(BaseModel):
+    """
+    Metaclass to render model results with jinja templates.
+
+    Each subclass needs to declare a :class:`typing.ClassVar` for a
+    jinja template within the `templates` directory.
+
+    Templates are written expecting each of the other TemplateModels
+    to already be rendered to strings - ie. rather than the ``class.py.jinja``
+    template receiving a full :class:`.PydanticAttribute` object or dictionary,
+    it receives it having already been rendered to a string. See the :meth:`.render` method.
+    """
+
+    template: ClassVar[str]
+    _environment: ClassVar[Environment]
+
+    meta_exclude: ClassVar[List[str]] = None
+
+    def render(self, environment: Optional[Environment] = None, **kwargs) -> str:
+        """
+        Recursively render a template model to a string.
+
+        For each field in the model, recurse through, rendering each :class:`.TemplateModel`
+        using the template set in :attr:`.TemplateModel.template` , but preserving the structure
+        of lists and dictionaries. Regular :class:`.BaseModel` s are rendered to dictionaries.
+        Any other value is passed through unchanged.
+
+        Args:
+            environment (:class:`jinja2.Environment`): Template environment - see :meth:`.environment`
+        """
+        if environment is None:
+            environment = TemplateModel.environment()
+
+        fields = {**self.model_fields, **self.model_computed_fields}
+
+        data = {k: _render(getattr(self, k, None), environment) for k in fields}
+        template = environment.get_template(self.template)
+        rendered = template.render(**data)
+        return rendered
+
+    @classmethod
+    def environment(cls) -> Environment:
+        """
+        Default environment for Template models.
+        uses a :class:`jinja2.PackageLoader` for the templates directory within this module
+        with the ``trim_blocks`` and ``lstrip_blocks`` parameters set to ``True`` so that the
+        default templates could be written in a more readable way.
+        """
+        return copy(cls._environment)
+
+    @classmethod
+    def exclude_from_meta(cls: "TemplateModel") -> List[str]:
+        """
+        Attributes in the source definition to exclude from linkml_meta
+        """
+        ret = [*cls.model_fields.keys()]
+        if cls.meta_exclude is not None:
+            ret = ret + cls.meta_exclude
+        return ret
+
+
+def _render(
+    item: Union[TemplateModel, Any, List[Union[Any, TemplateModel]], Dict[str, Union[Any, TemplateModel]]],
+    environment: Environment,
+) -> Union[str, List[str], Dict[str, str]]:
+    if isinstance(item, TemplateModel):
+        return item.render(environment)
+    elif isinstance(item, list):
+        return [_render(i, environment) for i in item]
+    elif isinstance(item, dict):
+        return {k: _render(v, environment) for k, v in item.items()}
+    elif isinstance(item, BaseModel):
+        fields = item.model_fields
+        return {k: _render(getattr(item, k, None), environment) for k in fields.keys()}
+    else:
+        return item

{linkml-1.8.1 → linkml-1.8.2}/linkml/generators/csvgen.py

@@ -95,7 +95,7 @@ class CsvGenerator(Generator):
 
 
 @shared_arguments(CsvGenerator)
-@click.command()
+@click.command(name="csv")
 @click.version_option(__version__, "-V", "--version")
 @click.option("--root", "-r", multiple=True, help="Class(es) to transform")
 def cli(yamlfile, root=None, **args):

{linkml-1.8.1 → linkml-1.8.2}/linkml/generators/docgen/slot.md.jinja2

@@ -34,6 +34,10 @@ _{{ element_description_line }}_
 {% endfor %}
 {% endif %}
 
+{% if element.abstract %}
+* __NOTE__: this is an abstract slot and should not be populated directly
+{% endif %}
+
 URI: {{ gen.uri_link(element) }}
 
 

{linkml-1.8.1 → linkml-1.8.2}/linkml/generators/docgen.py

@@ -978,7 +978,7 @@ YAML, and including it when necessary but not by default (e.g. in documentation
 """,
 )
 @click.version_option(__version__, "-V", "--version")
-@click.command()
+@click.command(name="doc")
 def cli(
     yamlfile,
     directory,

{linkml-1.8.1 → linkml-1.8.2}/linkml/generators/dotgen.py

@@ -136,7 +136,7 @@ class DotGenerator(Generator):
 
 
 @shared_arguments(DotGenerator)
-@click.command()
+@click.command(name="graphviz")
 @click.option(
     "--directory",
     "-d",

{linkml-1.8.1 → linkml-1.8.2}/linkml/generators/erdiagramgen.py

@@ -312,7 +312,7 @@ class ERDiagramGenerator(Generator):
 @click.option("--classes", "-c", multiple=True, help="List of classes to serialize")
 @click.option("--include-upstream", is_flag=True, help="Include upstream classes")
 @click.version_option(__version__, "-V", "--version")
-@click.command()
+@click.command(name="erdiagram")
 def cli(
     yamlfile,
     classes: List[str],

{linkml-1.8.1 → linkml-1.8.2}/linkml/generators/excelgen.py

@@ -167,7 +167,7 @@ class ExcelGenerator(Generator):
 
 
 @shared_arguments(ExcelGenerator)
-@click.command()
+@click.command(name="excel")
 @click.option(
     "--split-workbook-by-class",
     is_flag=True,

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

@@ -189,7 +189,7 @@ class GolangGenerator(Generator):
 
 @shared_arguments(GolangGenerator)
 @click.version_option(__version__, "-V", "--version")
-@click.command()
+@click.command(name="golang")
 def cli(yamlfile, **args):
     """Generate Golang types
 

{linkml-1.8.1 → linkml-1.8.2}/linkml/generators/golrgen.py

@@ -101,7 +101,7 @@ class GolrSchemaGenerator(Generator):
 
 
 @shared_arguments(GolrSchemaGenerator)
-@click.command()
+@click.command(name="golr-views")
 @click.option("--dir", "-d", default="golr-views", show_default=True, help="Output directory")
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, dir=None, **args):

{linkml-1.8.1 → linkml-1.8.2}/linkml/generators/graphqlgen.py

@@ -52,7 +52,7 @@ class GraphqlGenerator(Generator):
 
 
 @shared_arguments(GraphqlGenerator)
-@click.command()
+@click.command(name="graphql")
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, **args):
     """Generate graphql representation of a LinkML model"""

{linkml-1.8.1 → linkml-1.8.2}/linkml/generators/javagen.py

@@ -146,7 +146,7 @@ class JavaGenerator(OOCodeGenerator):
     help="Optional Java 17 record implementation",
 )
 @click.version_option(__version__, "-V", "--version")
-@click.command()
+@click.command(name="java")
 def cli(
     yamlfile,
     output_directory=None,

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

@@ -18,8 +18,7 @@ from rdflib import SKOS, XSD, Namespace
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
 
-URI_RANGES = (XSD.anyURI, SHEX.nonliteral, SHEX.bnode, SHEX.iri)
-
+URI_RANGES = (SHEX.nonliteral, SHEX.bnode, SHEX.iri)
 
 ENUM_CONTEXT = {
     "@vocab": "@null",
@@ -99,7 +98,7 @@ class ContextGenerator(Generator):
             comments.generation_date = self.schema.generation_date
             comments.source = self.schema.source_file
             context.comments = comments
-        context_content = {}
+        context_content = {"xsd": "http://www.w3.org/2001/XMLSchema#"}
         if base:
             base = str(base)
             if "://" not in base:
@@ -193,6 +192,7 @@ class ContextGenerator(Generator):
         elif not uri_prefix or is_default_namespace:
             definition["@id"] = uri_suffix
         else:
+
             definition["@id"] = (uri_prefix + ":" + uri_suffix) if uri_prefix else uri
 
         if uri_prefix and not is_default_namespace:
@@ -203,7 +203,7 @@ class ContextGenerator(Generator):
 
 
 @shared_arguments(ContextGenerator)
-@click.command()
+@click.command(name="jsonld-context")
 @click.option("--base", help="Base URI for model")
 @click.option(
     "--prefixes/--no-prefixes",

{linkml-1.8.1 → linkml-1.8.2}/linkml/generators/jsonldgen.py

@@ -192,7 +192,7 @@ class JSONLDGenerator(Generator):
 
 
 @shared_arguments(JSONLDGenerator)
-@click.command()
+@click.command(name="jsonld")
 @click.option(
     "--context",
     multiple=True,