feat(shaclgen): add --exclude-external-imports flag

Backport the exclude_external_imports capability from ContextGenerator
to ShaclGenerator. When enabled, shapes from URL-based external
vocabulary imports (http:// or https://) are excluded while local
file imports and linkml standard imports are kept.

This allows schemas that extend external ontologies to generate only
their own shapes without post-processing namespace filtering.

Signed-off-by: jdsika <carlo.van-driesten@bmw.de>

Author: jdsika

packages/linkml/src/linkml/generators/shaclgen.py

@@ -1,7 +1,7 @@
 import logging
 import os
 from collections.abc import Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 import click
 from jsonasobj2 import JsonObj, as_dict
@@ -16,6 +16,7 @@
 from linkml.utils.generator import Generator, shared_arguments
 from linkml_runtime.linkml_model.meta import ClassDefinition, ElementName
 from linkml_runtime.utils.formatutils import underscore
+from linkml_runtime.utils.schemaview import SchemaView
 from linkml_runtime.utils.yamlutils import TypedNode, extended_float, extended_int, extended_str
 
 logger = logging.getLogger(__name__)
@@ -62,6 +63,15 @@ class ShaclGenerator(Generator):
     """True means include all class / slot / type annotations in generated Node or Property shapes"""
     exclude_imports: bool = False
     """If True, elements from imported ontologies won't be included in the generator's output"""
+    exclude_external_imports: bool = False
+    """If True, elements from URL-based external vocabulary imports are excluded.
+
+    Local file imports and linkml standard imports are kept.  This is useful
+    when generating shapes for a schema that extends an external ontology —
+    only shapes defined in the local schema and its file-based imports are
+    emitted, while shapes from ``http(s)://``-based imports are suppressed.
+    """
+    _external_classes: set | None = field(default=None, repr=False)
     use_class_uri_names: bool = True
     """
     Control how SHACL shape URIs are generated.
@@ -84,6 +94,27 @@ class ShaclGenerator(Generator):
     def __post_init__(self) -> None:
         super().__post_init__()
         self.generate_header()
+        if self.exclude_external_imports:
+            sv = self.schemaview
+            self._external_classes = self._collect_external_classes(sv)
+
+    @staticmethod
+    def _collect_external_classes(sv: SchemaView) -> set[str]:
+        """Identify classes from URL-based external vocabulary imports.
+
+        Walks the SchemaView ``schema_map`` (populated by ``imports_closure``)
+        and collects class names from schemas whose import key starts with
+        ``http://`` or ``https://``.  Local file imports and ``linkml:``
+        standard imports are left untouched.
+        """
+        sv.imports_closure()
+        external_classes: set[str] = set()
+        for schema_key, schema_def in sv.schema_map.items():
+            if schema_key == sv.schema.name:
+                continue
+            if schema_key.startswith("http://") or schema_key.startswith("https://"):
+                external_classes.update(schema_def.classes.keys())
+        return external_classes
 
     def generate_header(self) -> str:
         out = f"\n# metamodel_version: {self.schema.metamodel_version}"
@@ -107,6 +138,8 @@ def as_graph(self) -> Graph:
             g.bind(str(pfx.prefix_prefix), pfx.prefix_reference)
 
         for c in sv.all_classes(imports=not self.exclude_imports).values():
+            if self.exclude_external_imports and self._external_classes and c.name in self._external_classes:
+                continue
 
             def shape_pv(p, v):
                 if v is not None:
@@ -508,6 +541,14 @@ def add_simple_data_type(func: Callable, r: ElementName) -> None:
     help="Use --exclude-imports to exclude imported elements from the generated SHACL shapes. This is useful when "
     "extending a substantial ontology to avoid large output files.",
 )
+@click.option(
+    "--exclude-external-imports/--include-external-imports",
+    default=False,
+    show_default=True,
+    help="Use --exclude-external-imports to exclude elements from URL-based external vocabulary imports while keeping "
+    "local file imports and linkml standard imports. Useful when extending an external ontology and only shapes for "
+    "the local schema are needed.",
+)
 @click.option(
     "--use-class-uri-names/--use-native-names",
     default=True,

tests/linkml/test_generators/test_shaclgen.py

@@ -1160,3 +1160,109 @@ def test_nodeidentifier_range_produces_blank_node_or_iri():
     uri_ref = props["https://example.org/uriRef"]
     uri_kinds = list(g.objects(uri_ref, SH.nodeKind))
     assert SH.IRI in uri_kinds, f"Expected sh:IRI for uri, got {uri_kinds}"
+
+
+def test_exclude_external_imports(tmp_path):
+    """With --exclude-external-imports, shapes from URL-based external
+    vocabulary imports are excluded, while local file imports are kept.
+    """
+    import textwrap
+
+    ext_dir = tmp_path / "ext"
+    ext_dir.mkdir()
+    (ext_dir / "external_vocab.yaml").write_text(
+        textwrap.dedent("""\
+            id: https://example.org/external-vocab
+            name: external_vocab
+            default_prefix: ext
+            prefixes:
+              linkml: https://w3id.org/linkml/
+              ext: https://example.org/external-vocab/
+            imports:
+              - linkml:types
+            slots:
+              issuer:
+                slot_uri: ext:issuer
+                range: string
+            classes:
+              ExternalCredential:
+                class_uri: ext:ExternalCredential
+                slots:
+                  - issuer
+        """),
+        encoding="utf-8",
+    )
+    local_dir = tmp_path / "local"
+    local_dir.mkdir()
+    (local_dir / "local_types.yaml").write_text(
+        textwrap.dedent("""\
+            id: https://example.org/local-types
+            name: local_types
+            default_prefix: loc
+            prefixes:
+              linkml: https://w3id.org/linkml/
+              loc: https://example.org/local-types/
+            imports:
+              - linkml:types
+            slots:
+              localField:
+                slot_uri: loc:localField
+                range: string
+            classes:
+              LocalType:
+                class_uri: loc:LocalType
+                slots:
+                  - localField
+        """),
+        encoding="utf-8",
+    )
+    (tmp_path / "main.yaml").write_text(
+        textwrap.dedent("""\
+            id: https://example.org/main
+            name: main
+            default_prefix: main
+            prefixes:
+              linkml: https://w3id.org/linkml/
+              main: https://example.org/main/
+              ext: https://example.org/external-vocab/
+              loc: https://example.org/local-types/
+            imports:
+              - linkml:types
+              - https://example.org/external-vocab
+              - ./local/local_types
+            slots:
+              localName:
+                slot_uri: main:localName
+                range: string
+            classes:
+              MainThing:
+                class_uri: main:MainThing
+                slots:
+                  - localName
+        """),
+        encoding="utf-8",
+    )
+
+    importmap = {"https://example.org/external-vocab": str(ext_dir / "external_vocab")}
+
+    shacl_text = ShaclGenerator(
+        str(tmp_path / "main.yaml"),
+        exclude_external_imports=True,
+        importmap=importmap,
+        base_dir=str(tmp_path),
+    ).serialize()
+
+    g = rdflib.Graph()
+    g.parse(data=shacl_text)
+
+    shapes = set(g.subjects(RDF.type, SH.NodeShape))
+    shape_strs = {str(s) for s in shapes}
+
+    # Local schema class must be present
+    assert any("MainThing" in s for s in shape_strs), f"Local class 'MainThing' missing, got: {shape_strs}"
+    # Local file import class must be present
+    assert any("LocalType" in s for s in shape_strs), f"Local file import 'LocalType' missing, got: {shape_strs}"
+    # External vocab class must NOT be present
+    assert not any("ExternalCredential" in s for s in shape_strs), (
+        f"External class 'ExternalCredential' should be excluded, got: {shape_strs}"
+    )