experimental: first pass at unified model transformations

linkml/transformers/model_transformer.py

@@ -0,0 +1,31 @@
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+from linkml_runtime import SchemaView
+from linkml_runtime.linkml_model import SlotDefinition, ClassDefinitionName
+
+
+@dataclass
+class ModelTransformer:
+    """
+    Base class for all model transformers
+    """
+    schemaview: SchemaView = None
+
+    @abstractmethod
+    def transform(
+            self, tgt_schema_name: str = None, top_class: ClassDefinitionName = None
+    ) -> Any:
+        raise NotImplementedError
+
+    def unfold_slot_range(self, slot: SlotDefinition):
+        union_ranges = []
+        for x in slot.any_of + slot.exactly_one_of:
+            if x.range:
+                union_ranges.append(x.range)
+        if not union_ranges:
+            union_ranges.append(slot.range)
+
+
+

linkml/transformers/oomodel_transformer.py

@@ -0,0 +1,95 @@
+from abc import ABC
+from dataclasses import dataclass
+from typing import Optional, List, Union
+
+from pydantic import BaseModel
+
+from linkml.transformers.model_transformer import ModelTransformer
+
+
+NAME = str
+
+
+class TargetLanguageProperties(BaseModel):
+    """
+    Properties for a target language
+    """
+    multiple_inheritance: Optional[bool] = None
+    ranges_as_unions: Optional[bool] = None
+    element_name_regex: Optional[str] = None
+    reserved_words: Optional[List[str]] = None
+
+
+class ProgramElement(BaseModel, ABC):
+    """
+    A base element in the object-oriented program model.
+
+    Each element must have a name. This should uniquely
+    identify within the context of the element type, and
+    in the scope of a module
+    """
+    name: NAME
+    doc: Optional[str] = None
+
+
+class ProgramPackage(ProgramElement):
+    pass
+
+
+class ProgramModule(ProgramElement):
+    pass
+
+
+RANGE = Union["DisjunctiveRangeExpression", "AtomicRangeExpression"]
+
+class RangeExpression(BaseModel, ABC):
+    """
+    A range expression
+    """
+    optional: Optional[bool] = None
+
+
+class DisjunctiveRangeExpression(RangeExpression):
+    """
+    A disjunctive range expression
+    """
+    ranges: List[RANGE]
+
+
+class AtomicRangeExpression(RangeExpression):
+    """
+    An atomic range expression
+    """
+    range: NAME
+    package: Optional[NAME] = None
+
+
+class ProgramField(ProgramElement):
+    """
+    A field (attribute, slot) in a class.
+    """
+    allowed_values: Optional[RANGE] = None
+    default_expression: Optional[str] = None
+
+
+
+class ProgramClass(ProgramElement):
+    """
+    A class in the object-oriented program model.
+    """
+    is_a: Optional[NAME] = None
+    mixins: Optional[List[NAME]] = None
+    class_attributes: Optional[List[ProgramField]] = None
+    fields: Optional[List[ProgramField]] = None
+
+
+
+class ProgramEnum(ProgramElement):
+    pass
+
+
+@dataclass
+class ObjectOrientedModelTransformer(ModelTransformer):
+    """
+    Transforms the source schema into an object-oriented model
+    """

linkml/transformers/relmodel_transformer.py

@@ -12,6 +12,8 @@
 from linkml_runtime.utils.schemaview import SchemaView, SlotDefinitionName
 from sqlalchemy import *
 
+from linkml.transformers.model_transformer import ModelTransformer
+
 
 class RelationalAnnotations(Enum):
     PRIMARY_KEY = "primary_key"
@@ -137,12 +139,11 @@ class TransformationResult:
 
 
 @dataclass
-class RelationalModelTransformer:
+class RelationalModelTransformer(ModelTransformer):
     """
     Transforms the source schema into a relational schema
     """
 
-    schemaview: SchemaView = None
     # dialect: str = field(default_factory=lambda : 'sqlite')
     skip_tree_root: bool = field(default_factory=lambda: False)
     skip_abstract: bool = field(default_factory=lambda: True)

linkml/transformers/schema_renamer.py

@@ -108,10 +108,17 @@ def _rename(self, element: Any, parent_key: ElementName = None) -> Any:
 
 @click.command()
 @click.option("-o", "--output", help="path to output schema")
-@click.option("-C", "--class-names", help="function for class names")
-@click.option("-S", "--slot-names", help="function for slot names")
+@click.option("-C", "--class-names", default="camel", show_default=True, help="function for class names")
+@click.option("-S", "--slot-names", default="snake", show_default=True, help="function for slot names")
 @click.argument("schema")
 def main(schema, output, class_names, slot_names):
+    """
+    Transforms a schema, renaming all elements to follow canonical casing conventions.
+
+    Example:
+
+        schema_renamer.py -C camelcase -S snakecase my_schema.yaml > my_schema_renamed.yaml
+    """
     sv = SchemaView(schema)
 
     def n2f(n: str) -> Callable: