linkml 1.8.1__tar.gz → 1.8.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.8.1
+Version: 1.8.3
 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.3/linkml/cli/__main__.py

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

linkml-1.8.3/linkml/cli/main.py

@@ -0,0 +1,130 @@
+"""
+Main ``linkml`` entrypoint
+
+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
+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()
+@click.version_option(__version__, "-V", "--version")
+def linkml():
+    """
+    LinkML: A flexible linked data modeling language
+    """
+
+
+@linkml.group()
+@click.version_option(__version__, "-V", "--version")
+def generate():
+    """
+    Generate formats from a LinkML schema
+    """
+
+
+@linkml.group()
+@click.version_option(__version__, "-V", "--version")
+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.3/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.3/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.3/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