linkml 1.8.4__py3-none-any.whl → 1.8.6__py3-none-any.whl

linkml/generators/graphqlgen.py

@@ -1,11 +1,14 @@
+import logging
 import os
+import re
 from dataclasses import dataclass
 
 import click
-from linkml_runtime.linkml_model.meta import ClassDefinition, SlotDefinition
+from linkml_runtime.linkml_model.meta import ClassDefinition, EnumDefinition, SlotDefinition
 from linkml_runtime.utils.formatutils import camelcase, lcamelcase
 
 from linkml._version import __version__
+from linkml.generators.common.naming import NameCompatibility, NamingProfiles
 from linkml.utils.generator import Generator, shared_arguments
 
 
@@ -19,6 +22,13 @@ class GraphqlGenerator(Generator):
     uses_schemaloader = True
     requires_metamodel = False
 
+    strict_naming: bool = False
+    _permissible_value_valid_characters = re.compile("^[_A-Za-z][_0-9A-Za-z]*?$")
+
+    def __post_init__(self):
+        self.name_compatiblity = NameCompatibility(profile=NamingProfiles.graphql, do_not_fix=self.strict_naming)
+        super().__post_init__()
+
     def visit_schema(self, **kwargs) -> str:
         return self.generate_header()
 
@@ -50,13 +60,35 @@ class GraphqlGenerator(Generator):
             slotrange = slotrange + "!"
         return f"\n    {lcamelcase(aliased_slot_name)}: {slotrange}"
 
+    def visit_enum(self, enum: EnumDefinition):
+        if enum.permissible_values:
+            permissible_values = []
+            for value in enum.permissible_values:
+                permissible_values.append(self.name_compatiblity.compatible(value))
+            values = "\n    ".join(permissible_values)
+            return f"enum {camelcase(enum.name).replace(' ','')}\n  {{\n    {values}\n  }}\n\n"
+        else:
+            logging.warning(
+                f"Enumeration {enum.name} using `reachable_from` instead of `permissible_values` "
+                + "to specify permissible values is not supported yet."
+                + "Enumeration {enum.name} will be silently ignored!!"
+            )
+            return ""
+
 
 @shared_arguments(GraphqlGenerator)
 @click.command(name="graphql")
+@click.option(
+    "--strict-naming",
+    is_flag=True,
+    show_default=True,
+    help="Treat warnings about invalid names or schema elements as errors.",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, **args):
     """Generate graphql representation of a LinkML model"""
-    print(GraphqlGenerator(yamlfile, **args).serialize(**args))
+    generator = GraphqlGenerator(yamlfile, **args)
+    print(generator.serialize(**args))
 
 
 if __name__ == "__main__":

linkml/generators/jsonldcontextgen.py

@@ -146,7 +146,13 @@ class ContextGenerator(Generator):
             slot_def = {}
             if not slot.usage_slot_name:
                 any_of_ranges = [any_of_el.range for any_of_el in slot.any_of]
-                if slot.range in self.schema.classes or any(rng in self.schema.classes for rng in any_of_ranges):
+                if slot.range in self.schema.classes:
+                    range_class_uri = self.schema.classes[slot.range].class_uri
+                    if range_class_uri and slot.inlined:
+                        slot_def["@type"] = range_class_uri
+                    else:
+                        slot_def["@type"] = "@id"
+                elif any(rng in self.schema.classes for rng in any_of_ranges):
                     slot_def["@type"] = "@id"
                 elif slot.range in self.schema.enums:
                     slot_def["@context"] = ENUM_CONTEXT

linkml/generators/jsonschemagen.py

@@ -21,8 +21,11 @@ from linkml_runtime.linkml_model.meta import (
 from linkml_runtime.utils.formatutils import be, camelcase, underscore
 
 from linkml._version import __version__
+from linkml.generators.common import build
+from linkml.generators.common.lifecycle import LifecycleMixin
 from linkml.generators.common.type_designators import get_type_designator_value
 from linkml.utils.generator import Generator, shared_arguments
+from linkml.utils.helpers import get_range_associated_slots
 
 logger = logging.getLogger(__name__)
 
@@ -177,8 +180,32 @@ class JsonSchema(dict):
         return JsonSchema(schema)
 
 
+class SchemaResult(build.SchemaResult):
+    """Top-level result of building a json schema"""
+
+    schema_: JsonSchema
+
+
+class EnumResult(build.EnumResult):
+    """A single built enum"""
+
+    schema_: JsonSchema
+
+
+class ClassResult(build.ClassResult):
+    """A single built class"""
+
+    schema_: JsonSchema
+
+
+class SlotResult(build.SlotResult):
+    """A slot within the context of a class"""
+
+    schema_: JsonSchema
+
+
 @dataclass
-class JsonSchemaGenerator(Generator):
+class JsonSchemaGenerator(Generator, LifecycleMixin):
     """
     Generates JSONSchema documents from a LinkML SchemaDefinition
 
@@ -187,6 +214,21 @@ class JsonSchemaGenerator(Generator):
     - Composition not yet implemented
     - Enumerations treated as strings
     - Foreign key references are treated as semantics-free strings
+
+    This generator implements the following :class:`.LifecycleMixin` methods:
+
+    * :meth:`.LifecycleMixin.before_generate_schema`
+    * :meth:`.LifecycleMixin.after_generate_schema`
+    * :meth:`.LifecycleMixin.before_generate_classes`
+    * :meth:`.LifecycleMixin.before_generate_enums`
+    * :meth:`.LifecycleMixin.before_generate_class_slots`
+    * :meth:`.LifecycleMixin.before_generate_class`
+    * :meth:`.LifecycleMixin.after_generate_class`
+    * :meth:`.LifecycleMixin.before_generate_class_slot`
+    * :meth:`.LifecycleMixin.after_generate_class_slot`
+    * :meth:`.LifecycleMixin.before_generate_enum`
+    * :meth:`.LifecycleMixin.after_generate_enum`
+
     """
 
     # ClassVars
@@ -233,7 +275,7 @@ class JsonSchemaGenerator(Generator):
             if self.schemaview.get_class(self.top_class) is None:
                 logger.warning(f"No class in schema named {self.top_class}")
 
-    def start_schema(self, inline: bool = False) -> JsonSchema:
+    def start_schema(self, inline: bool = False):
         self.inline = inline
 
         self.top_level_schema = JsonSchema(
@@ -249,6 +291,8 @@ class JsonSchemaGenerator(Generator):
         )
 
     def handle_class(self, cls: ClassDefinition) -> None:
+        cls = self.before_generate_class(cls, self.schemaview)
+
         if cls.mixin or cls.abstract:
             return
 
@@ -268,7 +312,10 @@ class JsonSchemaGenerator(Generator):
         if self.title_from == "title" and cls.title:
             class_subschema["title"] = cls.title
 
-        for slot_definition in self.schemaview.class_induced_slots(cls.name):
+        class_slots = self.before_generate_class_slots(
+            self.schemaview.class_induced_slots(cls.name), cls, self.schemaview
+        )
+        for slot_definition in class_slots:
             self.handle_class_slot(subschema=class_subschema, cls=cls, slot=slot_definition)
 
         rule_subschemas = []
@@ -318,6 +365,10 @@ class JsonSchemaGenerator(Generator):
                 class_subschema["allOf"] = []
             class_subschema["allOf"].extend(rule_subschemas)
 
+        class_subschema = self.after_generate_class(
+            ClassResult.model_construct(schema_=class_subschema, source=cls), self.schemaview
+        ).schema_
+
         self.top_level_schema.add_def(cls.name, class_subschema)
 
         if (self.top_class is not None and camelcase(self.top_class) == camelcase(cls.name)) or (
@@ -375,6 +426,7 @@ class JsonSchemaGenerator(Generator):
     def handle_enum(self, enum: EnumDefinition) -> None:
         # TODO: this only works with explicitly permitted values. It will need to be extended to
         # support other pv_formula
+        enum = self.before_generate_enum(enum, self.schemaview)
 
         def extract_permissible_text(pv):
             if isinstance(pv, str):
@@ -398,6 +450,10 @@ class JsonSchemaGenerator(Generator):
 
         if permissible_values_texts:
             enum_schema["enum"] = permissible_values_texts
+
+        enum_schema = self.after_generate_enum(
+            EnumResult.model_construct(schema_=enum_schema, source=enum), self.schemaview
+        ).schema_
         self.top_level_schema.add_def(enum.name, enum_schema)
 
     def get_type_info_for_slot_subschema(
@@ -490,7 +546,7 @@ class JsonSchemaGenerator(Generator):
                         range_id_slot,
                         range_simple_dict_value_slot,
                         range_required_slots,
-                    ) = self._get_range_associated_slots(slot)
+                    ) = get_range_associated_slots(self.schemaview, slot.range)
                     # if the range class has an ID and the slot is not inlined as a list, then we need to consider
                     # various inlined as dict formats
                     if range_id_slot is not None and not slot.inlined_as_list:
@@ -596,6 +652,7 @@ class JsonSchemaGenerator(Generator):
         return prop
 
     def handle_class_slot(self, subschema: JsonSchema, cls: ClassDefinition, slot: SlotDefinition) -> None:
+        slot = self.before_generate_class_slot(slot, cls, self.schemaview)
         class_id_slot = self.schemaview.get_identifier_slot(cls.name, use_key=True)
         value_required = (
             slot.required or slot == class_id_slot or slot.value_presence == PresenceEnum(PresenceEnum.PRESENT)
@@ -604,6 +661,9 @@ class JsonSchemaGenerator(Generator):
 
         aliased_slot_name = self.aliased_slot_name(slot)
         prop = self.get_subschema_for_slot(slot, include_null=self.include_null)
+        prop = self.after_generate_class_slot(
+            SlotResult.model_construct(schema_=prop, source=slot), cls, self.schemaview
+        ).schema_
         subschema.add_property(
             aliased_slot_name, prop, value_required=value_required, value_disallowed=value_disallowed
         )
@@ -613,65 +673,25 @@ class JsonSchemaGenerator(Generator):
             prop["enum"] = [type_value]
 
     def generate(self) -> JsonSchema:
+        self.schema = self.before_generate_schema(self.schema, self.schemaview)
         self.start_schema()
-        for enum_definition in self.schemaview.all_enums().values():
+
+        all_enums = self.before_generate_enums(self.schemaview.all_enums().values(), self.schemaview)
+        for enum_definition in all_enums:
             self.handle_enum(enum_definition)
 
-        for class_definition in self.schemaview.all_classes().values():
+        all_classes = self.before_generate_classes(self.schemaview.all_classes().values(), self.schemaview)
+        for class_definition in all_classes:
             self.handle_class(class_definition)
 
+        self.top_level_schema = self.after_generate_schema(
+            SchemaResult.model_construct(schema_=self.top_level_schema, source=self.schema), self.schemaview
+        ).schema_
         return self.top_level_schema
 
     def serialize(self, **kwargs) -> str:
         return self.generate().to_json(sort_keys=True, indent=self.indent if self.indent > 0 else None)
 
-    def _get_range_associated_slots(
-        self, slot: SlotDefinition
-    ) -> Tuple[Union[SlotDefinition, None], Union[SlotDefinition, None], Union[List[SlotDefinition], None]]:
-        range_class = self.schemaview.get_class(slot.range)
-        if range_class is None:
-            return None, None, None
-
-        range_class_id_slot = self.schemaview.get_identifier_slot(range_class.name, use_key=True)
-        if range_class_id_slot is None:
-            return None, None, None
-
-        non_id_slots = [
-            s for s in self.schemaview.class_induced_slots(range_class.name) if s.name != range_class_id_slot.name
-        ]
-        non_id_required_slots = [s for s in non_id_slots if s.required]
-
-        # Some lists of objects can be serialized as SimpleDicts.
-        # A SimpleDict is serialized as simple key-value pairs where the value is atomic.
-        # The key must be declared as a key, and the value must satisfy one of the following conditions:
-        # 1. The value slot is the only other slot in the object other than the key
-        # 2. The value slot is explicitly annotated as a simple_dict_value
-        # 3. The value slot is the only non-key that is required
-        # See also: https://github.com/linkml/linkml/issues/1250
-        range_simple_dict_value_slot = None
-        if len(non_id_slots) == 1:
-            range_simple_dict_value_slot = non_id_slots[0]
-        elif len(non_id_slots) > 1:
-            candidate_non_id_slots = []
-            for non_id_slot in non_id_slots:
-                if isinstance(non_id_slot.annotations, dict):
-                    is_simple_dict_value = non_id_slot.annotations.get("simple_dict_value", False)
-                else:
-                    is_simple_dict_value = getattr(non_id_slot.annotations, "simple_dict_value", False)
-                if is_simple_dict_value:
-                    candidate_non_id_slots.append(non_id_slot)
-            if len(candidate_non_id_slots) == 1:
-                range_simple_dict_value_slot = candidate_non_id_slots[0]
-            else:
-                candidate_non_id_slots = []
-                for non_id_slot in non_id_slots:
-                    if non_id_slot.required:
-                        candidate_non_id_slots.append(non_id_slot)
-                if len(candidate_non_id_slots) == 1:
-                    range_simple_dict_value_slot = candidate_non_id_slots[0]
-
-        return range_class_id_slot, range_simple_dict_value_slot, non_id_required_slots
-
 
 @shared_arguments(JsonSchemaGenerator)
 @click.command(name="json-schema")

linkml/generators/linkmlgen.py

@@ -78,6 +78,12 @@ class LinkmlGenerator(Generator):
 
 
 @shared_arguments(LinkmlGenerator)
+@click.option(
+    "--materialize/--no-materialize",
+    default=True,
+    show_default=True,
+    help="Materialize both, induced slots as attributes and structured patterns as patterns",
+)
 @click.option(
     "--materialize-attributes/--no-materialize-attributes",
     default=True,
@@ -86,7 +92,7 @@ class LinkmlGenerator(Generator):
 )
 @click.option(
     "--materialize-patterns/--no-materialize-patterns",
-    default=False,
+    default=True,
     show_default=True,
     help="Materialize structured patterns as patterns",
 )
@@ -100,11 +106,17 @@ class LinkmlGenerator(Generator):
 @click.command(name="linkml")
 def cli(
     yamlfile,
+    materialize: bool,
     materialize_attributes: bool,
     materialize_patterns: bool,
     output: FILE_TYPE = None,
     **kwargs,
 ):
+    # You can use the `--materialize` / `--no-materialize` for control
+    # over both attribute and pattern materialization.
+    materialize_attributes = bool(materialize)
+    materialize_patterns = bool(materialize)
+
     gen = LinkmlGenerator(
         yamlfile,
         materialize_attributes=materialize_attributes,

linkml/generators/owlgen.py

@@ -170,6 +170,9 @@ class OwlSchemaGenerator(Generator):
         default_factory=lambda: package_schemaview("linkml_runtime.linkml_model.meta")
     )
 
+    enum_iri_separator: str = "#"
+    """Separator for enum IRI. Can be overridden for example if your namespace IRI already contains a #"""
+
     def as_graph(self) -> Graph:
         """
         Generate an rdflib Graph from the LinkML schema.
@@ -1254,7 +1257,7 @@ class OwlSchemaGenerator(Generator):
         if pv.meaning:
             return URIRef(self.schemaview.expand_curie(pv.meaning))
         else:
-            return URIRef(enum_uri + "#" + pv.text.replace(" ", "+"))
+            return URIRef(enum_uri + self.enum_iri_separator + pv.text.replace(" ", "+"))
 
     def slot_owl_type(self, slot: SlotDefinition) -> URIRef:
         sv = self.schemaview
@@ -1353,6 +1356,13 @@ class OwlSchemaGenerator(Generator):
     show_default=True,
     help="Default OWL type for permissible values",
 )
+@click.option(
+    "--enum-iri-separator",
+    default="#",
+    is_flag=False,
+    show_default=True,
+    help="IRI separator for enums.",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, metadata_profile: str, **kwargs):
     """Generate an OWL representation of a LinkML model

linkml/generators/plantumlgen.py

@@ -49,14 +49,13 @@ class PlantumlGenerator(Generator):
     classes: Set[ClassDefinitionName] = None
     directory: Optional[str] = None
     kroki_server: Optional[str] = "https://kroki.io"
-    load_image: bool = True
     tooltips_flag: bool = False
+    dry_run: bool = False
 
     def visit_schema(
         self,
         classes: Set[ClassDefinitionName] = None,
         directory: Optional[str] = None,
-        load_image: bool = True,
         **_,
     ) -> Optional[str]:
         if directory:
@@ -96,20 +95,21 @@ class PlantumlGenerator(Generator):
         b64_diagram = base64.urlsafe_b64encode(zlib.compress(plantuml_code.encode(), 9))
 
         plantuml_url = self.kroki_server + "/plantuml/svg/" + b64_diagram.decode()
+        if self.dry_run:
+            return plantuml_url
         if directory:
             file_suffix = ".svg" if self.format == "puml" or self.format == "puml" else "." + self.format
             self.output_file_name = os.path.join(
                 directory,
                 camelcase(sorted(classes)[0] if classes else self.schema.name) + file_suffix,
             )
-            if load_image:
-                resp = requests.get(plantuml_url, stream=True, timeout=REQUESTS_TIMEOUT)
-                if resp.ok:
-                    with open(self.output_file_name, "wb") as f:
-                        for chunk in resp.iter_content(chunk_size=2048):
-                            f.write(chunk)
-                else:
-                    self.logger.error(f"{resp.reason} accessing {plantuml_url}")
+            resp = requests.get(plantuml_url, stream=True, timeout=REQUESTS_TIMEOUT)
+            if resp.ok:
+                with open(self.output_file_name, "wb") as f:
+                    for chunk in resp.iter_content(chunk_size=2048):
+                        f.write(chunk)
+            else:
+                self.logger.error(f"{resp.reason} accessing {plantuml_url}")
         else:
             out = (
                 "@startuml\n"
@@ -352,6 +352,13 @@ class PlantumlGenerator(Generator):
     help="URL of the Kroki server to use for diagram drawing",
     default="https://kroki.io",
 )
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    default=False,
+    show_default=True,
+    help="Print out Kroki URL calls instead of sending the real requests",
+)
 @click.version_option(__version__, "-V", "--version")
 def cli(yamlfile, **args):
     """Generate a UML representation of a LinkML model"""

linkml/generators/pydanticgen/array.py

@@ -1,7 +1,15 @@
 import sys
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import TYPE_CHECKING, Any, ClassVar, Generic, Iterable, List, Optional, Type, TypeVar, Union, get_args
+from typing import (
+    ClassVar,
+    Iterable,
+    List,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+)
 
 from linkml_runtime.linkml_model import Element
 from linkml_runtime.linkml_model.meta import ArrayExpression, DimensionExpression
@@ -9,20 +17,15 @@ from pydantic import VERSION as PYDANTIC_VERSION
 
 from linkml.utils.deprecation import deprecation_warning
 
-if int(PYDANTIC_VERSION[0]) >= 2:
-    from pydantic_core import core_schema
-else:
+if int(PYDANTIC_VERSION[0]) < 2:
     # Support for having pydantic 1 installed in the same environment will be dropped in 1.9.0
     deprecation_warning("pydantic-v1")
 
-if TYPE_CHECKING:
-    from pydantic import GetCoreSchemaHandler
-    from pydantic_core import CoreSchema
-
-if sys.version_info.minor <= 8:
-    from typing_extensions import Annotated
+if sys.version_info.minor < 12:
+    from typing_extensions import TypeAliasType
 else:
-    from typing import Annotated
+    from typing import TypeAliasType
+
 
 from linkml.generators.pydanticgen.build import RangeResult
 from linkml.generators.pydanticgen.template import ConditionalImport, Import, Imports, ObjectImport
@@ -37,75 +40,32 @@ class ArrayRepresentation(Enum):
 _BOUNDED_ARRAY_FIELDS = ("exact_number_dimensions", "minimum_number_dimensions", "maximum_number_dimensions")
 
 _T = TypeVar("_T")
-_RecursiveListType = Iterable[Union[_T, Iterable["_RecursiveListType"]]]
-
-
-class AnyShapeArrayType(Generic[_T]):
-    @classmethod
-    def __get_pydantic_core_schema__(cls, source_type: Any, handler: "GetCoreSchemaHandler") -> "CoreSchema":
-        # double-nested parameterized types here
-        # source_type: List[Union[T,List[...]]]
-        item_type = (Any,) if get_args(get_args(source_type)[0])[0] is _T else get_args(get_args(source_type)[0])[:-1]
-
-        if len(item_type) == 1:
-            item_schema = handler.generate_schema(item_type[0])
-        else:
-            item_schema = core_schema.union_schema([handler.generate_schema(i) for i in item_type])
-
-        if all([getattr(i, "__module__", "") == "builtins" and i is not Any for i in item_type]):
-            item_schema["strict"] = True
-
-        # Before python 3.11, `Any` type was a special object without a __name__
-        item_name = "_".join(["Any" if i is Any else i.__name__ for i in item_type])
-
-        array_ref = f"any-shape-array-{item_name}"
-
-        schema = core_schema.definitions_schema(
-            core_schema.list_schema(core_schema.definition_reference_schema(array_ref)),
-            [
-                core_schema.union_schema(
-                    [
-                        core_schema.list_schema(core_schema.definition_reference_schema(array_ref)),
-                        item_schema,
-                    ],
-                    ref=array_ref,
-                )
-            ],
-        )
-
-        return schema
-
-
-AnyShapeArray = Annotated[_RecursiveListType, AnyShapeArrayType]
+AnyShapeArray = TypeAliasType("AnyShapeArray", Iterable[Union[_T, Iterable["AnyShapeArray[_T]"]]], type_params=(_T,))
 
 _AnyShapeArrayImports = (
     Imports()
     + Import(
         module="typing",
         objects=[
-            ObjectImport(name="Generic"),
             ObjectImport(name="Iterable"),
             ObjectImport(name="TypeVar"),
             ObjectImport(name="Union"),
-            ObjectImport(name="get_args"),
         ],
     )
     + ConditionalImport(
-        condition="sys.version_info.minor > 8",
+        condition="sys.version_info.minor >= 12",
         module="typing",
-        objects=[ObjectImport(name="Annotated")],
-        alternative=Import(module="typing_extensions", objects=[ObjectImport(name="Annotated")]),
+        objects=[ObjectImport(name="TypeAliasType")],
+        alternative=Import(module="typing_extensions", objects=[ObjectImport(name="TypeAliasType")]),
     )
-    + Import(module="pydantic", objects=[ObjectImport(name="GetCoreSchemaHandler")])
-    + Import(module="pydantic_core", objects=[ObjectImport(name="CoreSchema"), ObjectImport(name="core_schema")])
 )
 
 # annotated types are special and inspect.getsource() can't stringify them
 _AnyShapeArrayInjects = [
     '_T = TypeVar("_T")',
-    '_RecursiveListType = Iterable[Union[_T, Iterable["_RecursiveListType"]]]',
-    AnyShapeArrayType,
-    "AnyShapeArray = Annotated[_RecursiveListType, AnyShapeArrayType]",
+    """AnyShapeArray = TypeAliasType(
+    "AnyShapeArray", Iterable[Union[_T, Iterable["AnyShapeArray[_T]"]]], type_params=(_T,)
+)""",
 ]
 
 _ConListImports = Imports() + Import(module="pydantic", objects=[ObjectImport(name="conlist")])

linkml/generators/pydanticgen/template.py

@@ -675,7 +675,18 @@ class PydanticModule(PydanticTemplateModel):
         return [c.name for c in self.classes.values()]
 
 
-_some_stdlib_module_names = {"copy", "datetime", "decimal", "enum", "inspect", "os", "re", "sys", "typing"}
+_some_stdlib_module_names = {
+    "copy",
+    "datetime",
+    "decimal",
+    "enum",
+    "inspect",
+    "os",
+    "re",
+    "sys",
+    "typing",
+    "dataclasses",
+}
 """
 sys.stdlib_module_names is only present in 3.10 and later
 so we make a cheap copy of the stdlib modules that we commonly use here,

linkml/generators/pydanticgen/templates/attribute.py.jinja

@@ -1,4 +1,4 @@
-{{name}}: {{ range }} = Field({{ field }}
+{{name}}: {{ range }} = Field(default={{ field }}
 {%- if title != None %}, title="{{title}}"{% endif -%}
 {%- if description %}, description="""{{description}}"""{% endif -%}
 {%- if equals_number != None %}

linkml/generators/python/python_ifabsent_processor.py

@@ -71,7 +71,7 @@ class PythonIfAbsentProcessor(IfAbsentProcessor):
     def map_enum_default_value(
         self, enum_name: EnumDefinitionName, permissible_value_name: str, slot: SlotDefinition, cls: ClassDefinition
     ):
-        return f"{enum_name}.{permissible_value_name}"
+        return f"'{permissible_value_name}'"
 
     def map_nc_name_default_value(self, default_value: str, slot: SlotDefinition, cls: ClassDefinition):
         raise NotImplementedError()