linkml 1.6.3__py3-none-any.whl → 1.6.5__py3-none-any.whl

linkml/generators/docgen/class.md.jinja2

@@ -1,7 +1,11 @@
-{%- if element.title -%}
-    {%- set title = element.title ~ ' (' ~ gen.name(element) ~ ')' -%}
-{%- else -%}
-    {%- set title = gen.name(element) -%}
+{%- if element.title %}
+    {%- set title = element.title ~ ' (' ~ element.name ~ ')' -%}
+{%- else %}
+    {%- if gen.use_class_uris -%}
+        {%- set title = element.name -%}
+    {%- else -%}
+        {%- set title = gen.name(element) -%}
+    {%- endif -%}
 {%- endif -%}
 
 # Class: {{ title }}

linkml/generators/docgen/slot.md.jinja2

@@ -1,7 +1,11 @@
 {%- if element.title %}
     {%- set title = element.title ~ ' (' ~ element.name ~ ')' -%}
 {%- else %}
-    {%- set title = gen.name(element) -%}
+    {%- if gen.use_slot_uris -%}
+        {%- set title = element.name -%}
+    {%- else -%}
+        {%- set title = gen.name(element) -%}
+    {%- endif -%}
 {%- endif -%}
 
 # Slot: {{ title }}

linkml/generators/docgen.py

@@ -150,6 +150,7 @@ class DocGenerator(Generator):
     gen_slots: bool = field(default_factory=lambda: True)
     no_types_dir: bool = field(default_factory=lambda: False)
     use_slot_uris: bool = field(default_factory=lambda: False)
+    use_class_uris: bool = field(default_factory=lambda: False)
     hierarchical_class_view: bool = field(default_factory=lambda: False)
 
     def __post_init__(self):
@@ -331,6 +332,13 @@ class DocGenerator(Generator):
                     return curie.split(":")[1]
 
             return underscore(element.name)
+        elif type(element).class_name == "class_definition":
+            if self.use_class_uris:
+                curie = self.schemaview.get_uri(element)
+                if curie:
+                    return curie.split(":")[1]
+
+            return camelcase(element.name)
         else:
             return camelcase(element.name)
 
@@ -374,6 +382,10 @@ class DocGenerator(Generator):
         if self._is_external(e):
             return self.uri_link(e)
         elif isinstance(e, ClassDefinition):
+            if self.use_class_uris:
+                curie = self.schemaview.get_uri(e)
+                if curie is not None:
+                    return self._markdown_link(n=curie.split(":")[1], name=e.name)
             return self._markdown_link(camelcase(e.name))
         elif isinstance(e, EnumDefinition):
             return self._markdown_link(camelcase(e.name))
@@ -474,7 +486,7 @@ class DocGenerator(Generator):
     ) -> str:
         indent = " " * depth * 4
 
-        if self.use_slot_uris:
+        if self.use_slot_uris or self.use_class_uris:
             name = self.schemaview.get_element(element).name
         else:
             name = self.name(element)
@@ -878,6 +890,11 @@ class DocGenerator(Generator):
     default=False,
     help="Use IDs from slot_uri instead of names",
 )
+@click.option(
+    "--use-class-uris/--no-use-class-uris",
+    default=False,
+    help="Use IDs from class_uri instead of names",
+)
 @click.option(
     "--hierarchical-class-view/--no-hierarchical-class-view",
     default=True,
@@ -889,7 +906,17 @@ class DocGenerator(Generator):
 )
 @click.version_option(__version__, "-V", "--version")
 @click.command()
-def cli(yamlfile, directory, index_name, dialect, template_directory, use_slot_uris, hierarchical_class_view, **args):
+def cli(
+    yamlfile,
+    directory,
+    index_name,
+    dialect,
+    template_directory,
+    use_slot_uris,
+    use_class_uris,
+    hierarchical_class_view,
+    **args,
+):
     """Generate documentation folder from a LinkML YAML schema
 
     Currently a default set of templates for markdown is provided (see the
@@ -915,6 +942,7 @@ def cli(yamlfile, directory, index_name, dialect, template_directory, use_slot_u
         dialect=dialect,
         template_directory=template_directory,
         use_slot_uris=use_slot_uris,
+        use_class_uris=use_class_uris,
         hierarchical_class_view=hierarchical_class_view,
         index_name=index_name,
         **args,

linkml/generators/excelgen.py

@@ -1,6 +1,6 @@
 import logging
-import os
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from pathlib import Path
 from typing import List
 
 import click
@@ -8,78 +8,80 @@ from linkml_runtime.utils.schemaview import SchemaView
 from openpyxl import Workbook
 from openpyxl.utils import get_column_letter
 from openpyxl.worksheet.datavalidation import DataValidation
-from openpyxl.worksheet.worksheet import Worksheet
 
 from linkml._version import __version__
 from linkml.utils.generator import Generator, shared_arguments
-from linkml.utils.helpers import convert_to_snake_case
 
 
 @dataclass
 class ExcelGenerator(Generator):
     # ClassVars
-    generatorname = os.path.basename(__file__)
+    generatorname = Path(__file__).name
     generatorversion = "0.1.1"
     valid_formats = ["xlsx"]
     uses_schemaloader = False
     requires_metamodel = False
 
+    split_workbook_by_class: bool = field(default_factory=lambda: False)
+
     def __post_init__(self) -> None:
         super().__post_init__()
         self.logger = logging.getLogger(__name__)
         self.schemaview = SchemaView(self.schema)
 
-    def create_workbook(self, workbook_name: str) -> Workbook:
+    def create_workbook(self, workbook_path: Path) -> Workbook:
         """
         Creates an Excel workbook using the openpyxl library and returns it.
 
-        :param workbook_name: Name of the workbook to be created.
+        :param workbook_path: Path of the workbook to be created.
         :return: An openpyxl Workbook object representing the newly created workbook.
         """
         workbook = Workbook()
-        workbook.title = workbook_name
+        workbook.save(workbook_path)
         return workbook
 
-    def get_workbook_name(self, workbook: Workbook) -> str:
-        """
-        Returns the name of the given workbook.
-
-        :param workbook: The workbook whose name should be returned.
-        :return: Name of the workbook.
-        """
-        return workbook.title
-
-    def remove_worksheet_by_name(self, workbook: Workbook, worksheet_name: str) -> None:
-        """
-        Remove worksheet from workbook by name.
-        """
-        worksheet = workbook[worksheet_name]
-        workbook.remove(worksheet)
-
-    def create_worksheet(self, workbook: Workbook, worksheet_name: str) -> Worksheet:
+    def create_workbook_and_worksheets(self, output_path: Path, classes: List[str]) -> None:
         """
-        Creates an Excel worksheet with the given name in the given workbook.
+        Creates a workbook with worksheets for each class.
 
-        :param workbook: The workbook to which the worksheet should be added.
-        :param worksheet_name: Name of the worksheet to be created.
+        :param output_path: The path where the workbook should be created.
+        :param classes: List of class names for which worksheets should be created.
         """
-        worksheet = workbook.create_sheet(worksheet_name)
-        workbook_name = self.get_workbook_name(workbook)
-        workbook.save(workbook_name)
+        workbook = self.create_workbook(output_path)
+        workbook.remove(workbook.active)
+        sv = self.schemaview
 
-        return worksheet
+        for cls_name in classes:
+            cls = sv.get_class(class_name=cls_name, imports=self.mergeimports)
+            if not cls.mixin and not cls.abstract:
+                workbook.create_sheet(cls_name)
 
-    def create_schema_worksheets(self, workbook: str) -> None:
-        """
-        Creates worksheets in a given Excel workbook based on the classes in the
-        schema.
+                # Add columns to the worksheet for the current class
+                slots = [s.name for s in sv.class_induced_slots(cls_name, self.mergeimports)]
+                self.add_columns_to_worksheet(workbook, cls_name, slots)
+                workbook.save(output_path)
 
-        :param workbook: The workbook to which the worksheet should be added.
-        """
-        sv = self.schemaview
-        for cls_name, cls in sv.all_classes(imports=self.mergeimports).items():
-            if not cls.mixin and not cls.abstract:
-                self.create_worksheet(workbook, cls_name)
+                # Add enum validation for columns with enum types
+                enum_list = list(sv.all_enums(imports=self.mergeimports).keys())
+                for s in sv.class_induced_slots(cls_name, self.mergeimports):
+                    if s.range in enum_list:
+                        pv_list = list(sv.get_enum(s.range).permissible_values.keys())
+
+                        # Check if the total length of permissible values is <= 255 characters
+                        enum_length = sum(len(value) for value in pv_list)
+                        if enum_length <= 255:
+                            self.column_enum_validation(workbook, cls_name, s.name, pv_list)
+                        else:
+                            self.logger.warning(
+                                f"'{s.range}' has permissible values with total "
+                                "length > 255 characters. Dropdowns may not work properly "
+                                f"in {output_path}"
+                            )
+                    workbook.save(output_path)
+
+        workbook.save(output_path)
+        if self.split_workbook_by_class:
+            self.logger.info(f"The Excel workbooks have been written to {output_path}")
 
     def add_columns_to_worksheet(self, workbook: Workbook, worksheet_name: str, sheet_headings: List[str]) -> None:
         """
@@ -96,10 +98,6 @@ class ExcelGenerator(Generator):
         for i, heading in enumerate(sheet_headings):
             worksheet.cell(row=1, column=i + 1, value=heading)
 
-        # Save the changes to the workbook
-        workbook_name = self.get_workbook_name(workbook)
-        workbook.save(workbook_name)
-
     def column_enum_validation(
         self,
         workbook: Workbook,
@@ -129,48 +127,52 @@ class ExcelGenerator(Generator):
 
         dv.add(f"{column_letter}2:{column_letter}1048576")
 
-        workbook_name = self.get_workbook_name(workbook)
-        workbook.save(workbook_name)
-
     def serialize(self, **kwargs) -> str:
-        self.output = (
-            os.path.abspath(convert_to_snake_case(self.schema.name) + ".xlsx") if not self.output else self.output
-        )
+        sv = self.schemaview
+        classes_to_process = [
+            cls_name
+            for cls_name, cls in sv.all_classes(imports=self.mergeimports).items()
+            if not cls.mixin and not cls.abstract
+        ]
 
-        workbook = self.create_workbook(self.output)
-        self.remove_worksheet_by_name(workbook, "Sheet")
-        self.create_schema_worksheets(workbook)
+        if self.split_workbook_by_class:
+            output_path = Path(self.schema.name + "_worksheets") if not self.output else Path(self.output)
+            output_path = output_path.absolute()
 
-        sv = self.schemaview
-        for cls_name, cls in sv.all_classes(imports=self.mergeimports).items():
-            if not cls.mixin and not cls.abstract:
-                slots = [s.name for s in sv.class_induced_slots(cls_name, imports=self.mergeimports)]
-                self.add_columns_to_worksheet(workbook, cls_name, slots)
+            if not output_path.is_dir():
+                output_path.mkdir(parents=True, exist_ok=True)
 
-        enum_list = [e_name for e_name, _ in sv.all_enums(imports=self.mergeimports).items()]
-        for cls_name, cls in sv.all_classes(imports=self.mergeimports).items():
-            if not cls.mixin and not cls.abstract:
-                for s in sv.class_induced_slots(cls_name, imports=self.mergeimports):
-                    if s.range in enum_list:
-                        pv_list = []
-                        for pv_name, _ in sv.get_enum(s.range).permissible_values.items():
-                            pv_list.append(pv_name)
-                        self.column_enum_validation(workbook, cls_name, s.name, pv_list)
-        self.logger.info(f"The Excel workbook has been written to {self.output}")
+            for cls_name in classes_to_process:
+                cls_output_path = output_path.joinpath(f"{cls_name}.xlsx")
+                self.create_workbook_and_worksheets(cls_output_path, [cls_name])
+                self.logger.info(f"The Excel workbook for class '{cls_name}' has been written to {cls_output_path}")
+        else:
+            output_path = Path(self.schema.name + ".xlsx") if not self.output else Path(self.output)
+            output_path = output_path.absolute()
+
+            self.create_workbook_and_worksheets(output_path, classes_to_process)
+
+            self.logger.info(f"The Excel workbook has been written to {output_path}")
 
 
 @shared_arguments(ExcelGenerator)
 @click.command()
+@click.option(
+    "--split-workbook-by-class",
+    is_flag=True,
+    default=False,
+    help="""Split model into separate Excel workbooks/files, one for each class""",
+)
 @click.option(
     "-o",
     "--output",
     type=click.Path(),
-    help="""Name of Excel spreadsheet to be created""",
+    help="""Name of Excel spreadsheet to be created, or name of directory to create split workbooks in""",
 )
 @click.version_option(__version__, "-V", "--version")
-def cli(yamlfile, **kwargs):
+def cli(yamlfile, split_workbook_by_class, **kwargs):
     """Generate Excel representation of a LinkML model"""
-    ExcelGenerator(yamlfile, **kwargs).serialize(**kwargs)
+    ExcelGenerator(yamlfile, split_workbook_by_class=split_workbook_by_class, **kwargs).serialize(**kwargs)
 
 
 if __name__ == "__main__":

linkml/generators/javagen/java_record_template.jinja2

@@ -5,8 +5,8 @@ package {{ doc.package }};
 import java.math.BigDecimal;{% endif -%}
 {% if f.range.startswith('Instant') %}
 import java.time.Instant;{% endif -%}
-{% if f.range.startswith('LocalDateTime') %}
-import java.time.LocalDateTime;{% endif -%}
+{% if f.range.startswith('LocalDate') %}
+import java.time.LocalDate;{% endif -%}
 {% if f.range.startswith('ZonedDateTime') %}
 import java.time.ZonedDateTime;{% endif -%}
 {% if f.range.startswith('List') %}

linkml/generators/javagen.py

@@ -45,9 +45,9 @@ TYPEMAP = {
     "xsd:float": "Float",
     "xsd:double": "Double",
     "xsd:boolean": "boolean",
-    "xds:dateTime": "ZonedDateTime",
-    "xds:date": "LocalDateTime",
-    "xds:time": "Instant",
+    "xsd:dateTime": "ZonedDateTime",
+    "xsd:date": "LocalDate",
+    "xsd:time": "Instant",
     "xsd:anyURI": "String",
     "xsd:decimal": "BigDecimal",
 }

linkml/generators/jsonschemagen.py

@@ -65,19 +65,23 @@ class JsonSchema(UserDict):
             identifier_name = self._lax_forward_refs.pop(canonical_name)
             self.add_lax_def(canonical_name, identifier_name)
 
-    def add_lax_def(self, name: str, identifier_name: str) -> None:
+    def add_lax_def(self, names: Union[str, List[str]], identifier_name: str) -> None:
         # JSON-Schema does not have inheritance,
         # so we duplicate slots from inherited parents and mixins
         # Maps e.g. Person --> Person__identifier_optional
         # for use when Person is a range of an inlined-as-dict slot
-        canonical_name = camelcase(name)
+        if isinstance(names, str):
+            names = [names]
 
-        if "$defs" not in self or canonical_name not in self["$defs"]:
-            self._lax_forward_refs[canonical_name] = identifier_name
-        else:
-            lax_cls = deepcopy(self["$defs"][canonical_name])
-            lax_cls["required"].remove(identifier_name)
-            self["$defs"][canonical_name + self.OPTIONAL_IDENTIFIER_SUFFIX] = lax_cls
+        for name in names:
+            canonical_name = camelcase(name)
+
+            if "$defs" not in self or canonical_name not in self["$defs"]:
+                self._lax_forward_refs[canonical_name] = identifier_name
+            else:
+                lax_cls = deepcopy(self["$defs"][canonical_name])
+                lax_cls["required"].remove(identifier_name)
+                self["$defs"][canonical_name + self.OPTIONAL_IDENTIFIER_SUFFIX] = lax_cls
 
     def add_property(self, name: str, subschema: "JsonSchema", required: bool = False) -> None:
         canonical_name = underscore(name)

linkml/generators/pydanticgen.py

@@ -32,7 +32,7 @@ from linkml.utils.generator import shared_arguments
 from linkml.utils.ifabsent_functions import ifabsent_value_declaration
 
 
-def default_template(pydantic_ver: str = "1") -> str:
+def default_template(pydantic_ver: str = "1", extra_fields: str = "forbid") -> str:
     """Constructs a default template for pydantic classes based on the version of pydantic"""
     ### HEADER ###
     template = """
@@ -64,7 +64,7 @@ version = "{{version if version else None}}"
 """
     ### BASE MODEL ###
     if pydantic_ver == "1":
-        template += """
+        template += f"""
 class WeakRefShimBaseModel(BaseModel):
    __slots__ = '__weakref__'
 
@@ -72,18 +72,18 @@ class ConfiguredBaseModel(WeakRefShimBaseModel,
                 validate_assignment = True,
                 validate_all = True,
                 underscore_attrs_are_private = True,
-                extra = {% if allow_extra %}'allow'{% else %}'forbid'{% endif %},
+                extra = '{extra_fields}',
                 arbitrary_types_allowed = True,
                 use_enum_values = True):
     pass
 """
     else:
-        template += """
+        template += f"""
 class ConfiguredBaseModel(BaseModel):
     model_config = ConfigDict(
         validate_assignment=True,
         validate_default=True,
-        extra={% if allow_extra %}'allow'{% else %}'forbid'{% endif %},
+        extra = '{extra_fields}',
         arbitrary_types_allowed=True,
         use_enum_values = True)
 """
@@ -108,7 +108,46 @@ class {{ e.name }}(str{% if e['values'] %}, Enum{% endif %}):
 {% endfor %}
 """
     ### CLASSES ###
-    template += """
+    if pydantic_ver == "1":
+        template += """
+{%- for c in schema.classes.values() %}
+class {{ c.name }}
+    {%- if class_isa_plus_mixins[c.name] -%}
+        ({{class_isa_plus_mixins[c.name]|join(', ')}})
+    {%- else -%}
+        (ConfiguredBaseModel)
+    {%- endif -%}
+                  :
+    {% if c.description -%}
+    \"\"\"
+    {{ c.description }}
+    \"\"\"
+    {%- endif %}
+    {% for attr in c.attributes.values() if c.attributes -%}
+    {{attr.name}}: {{ attr.annotations['python_range'].value }} = Field(
+    {%- if predefined_slot_values[c.name][attr.name] -%}
+        {{ predefined_slot_values[c.name][attr.name] }}
+    {%- elif (attr.required or attr.identifier or attr.key) -%}
+        ...
+    {%- else -%}
+        None
+    {%- endif -%}
+    {%- if attr.title != None %}, title="{{attr.title}}"{% endif -%}
+    {%- if attr.description %}, description=\"\"\"{{attr.description}}\"\"\"{% endif -%}
+    {%- if attr.pattern %}, regex=\"{{attr.pattern}}\"{% endif -%}
+    {%- if attr.equals_number != None %}, le={{attr.equals_number}}, ge={{attr.equals_number}}
+    {%- else -%}
+     {%- if attr.minimum_value != None %}, ge={{attr.minimum_value}}{% endif -%}
+     {%- if attr.maximum_value != None %}, le={{attr.maximum_value}}{% endif -%}
+    {%- endif -%}
+    )
+    {% else -%}
+    None
+    {% endfor %}
+{% endfor %}
+"""
+    elif pydantic_ver == "2":
+        template += """
 {%- for c in schema.classes.values() %}
 class {{ c.name }}
     {%- if class_isa_plus_mixins[c.name] -%}
@@ -133,6 +172,7 @@ class {{ c.name }}
     {%- endif -%}
     {%- if attr.title != None %}, title="{{attr.title}}"{% endif -%}
     {%- if attr.description %}, description=\"\"\"{{attr.description}}\"\"\"{% endif -%}
+    {%- if attr.pattern %}, pattern=\"{{attr.pattern}}\"{% endif -%}
     {%- if attr.equals_number != None %}, le={{attr.equals_number}}, ge={{attr.equals_number}}
     {%- else -%}
      {%- if attr.minimum_value != None %}, ge={{attr.minimum_value}}{% endif -%}
@@ -144,6 +184,7 @@ class {{ c.name }}
     {% endfor %}
 {% endfor %}
 """
+
     ### FWD REFS / REBUILD MODEL ###
     if pydantic_ver == "1":
         template += """
@@ -196,7 +237,7 @@ class PydanticGenerator(OOCodeGenerator):
     # ObjectVars
     pydantic_version: str = field(default_factory=lambda: PYDANTIC_VERSION[0])
     template_file: str = None
-    allow_extra: bool = field(default_factory=lambda: False)
+    extra_fields: str = field(default_factory=lambda: "forbid")
     gen_mixin_inheritance: bool = field(default_factory=lambda: True)
 
     # ObjectVars (identical to pythongen)
@@ -454,7 +495,7 @@ class PydanticGenerator(OOCodeGenerator):
             with open(self.template_file) as template_file:
                 template_obj = Template(template_file.read())
         else:
-            template_obj = Template(default_template(self.pydantic_version))
+            template_obj = Template(default_template(self.pydantic_version, self.extra_fields))
 
         sv: SchemaView
         sv = self.schemaview
@@ -536,7 +577,7 @@ class PydanticGenerator(OOCodeGenerator):
             underscore=underscore,
             enums=enums,
             predefined_slot_values=self.get_predefined_slot_values(),
-            allow_extra=self.allow_extra,
+            extra_fields=self.extra_fields,
             metamodel_version=self.schema.metamodel_version,
             version=self.schema.version,
             class_isa_plus_mixins=self.get_class_isa_plus_mixins(),
@@ -548,13 +589,19 @@ class PydanticGenerator(OOCodeGenerator):
 
 
 @shared_arguments(PydanticGenerator)
-@click.option("--template_file", help="Optional jinja2 template to use for class generation")
+@click.option("--template-file", help="Optional jinja2 template to use for class generation")
 @click.option(
-    "--pydantic_version",
+    "--pydantic-version",
     type=click.Choice(["1", "2"]),
     default="1",
     help="Pydantic version to use (1 or 2)",
 )
+@click.option(
+    "--extra-fields",
+    type=click.Choice(["allow", "ignore", "forbid"], case_sensitive=False),
+    default="forbid",
+    help="How to handle extra fields in BaseModel.",
+)
 @click.version_option(__version__, "-V", "--version")
 @click.command()
 def cli(
@@ -566,6 +613,7 @@ def cli(
     classvars=True,
     slots=True,
     pydantic_version="1",
+    extra_fields="forbid",
     **args,
 ):
     """Generate pydantic classes to represent a LinkML model"""
@@ -573,6 +621,7 @@ def cli(
         yamlfile,
         template_file=template_file,
         pydantic_version=pydantic_version,
+        extra_fields=extra_fields,
         emit_metadata=head,
         genmeta=genmeta,
         gen_classvars=classvars,

linkml/generators/pythongen.py

@@ -509,6 +509,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         initializers += [self.gen_class_variable(cls, slot, False) for slot in slot_variables]
 
         # Followed by everything else
+
         slot_variables = self._slot_iter(cls, lambda slot: not slot.required and slot in domain_slots)
         initializers += [self.gen_class_variable(cls, slot, False) for slot in slot_variables]
 
@@ -604,7 +605,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
 
     def class_reference_type(self, slot: SlotDefinition, cls: Optional[ClassDefinition]) -> Tuple[str, str, str]:
         """
-        Return the type of a slot referencing a class
+        Return the type of slot referencing a class
 
         :param slot: slot to be typed
         :param cls: owning class.  Used for generating key references
@@ -734,6 +735,12 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         return typ_name
 
     def gen_constructor(self, cls: ClassDefinition) -> Optional[str]:
+        """
+        Generate python constructor for class
+
+        :param cls: class to generate constructor for
+        :return: python constructor
+        """
         rlines: List[str] = []
         designators = [x for x in self.domain_slots(cls) if x.designates_type]
         if len(designators) > 0:
@@ -845,7 +852,7 @@ dataclasses._init_fn = dataclasses_init_fn_with_kwargs
         elif slot.inlined:
             slot_range_cls = self.schema.classes[slot.range]
             identifier = self.class_identifier(slot_range_cls)
-            # If we don't have an identifier and we are expecting to be inlined first class elements
+            # If we don't have an identifier, and we are expecting to be inlined first class elements
             # (inlined_as_list is not True), we will use the first required field as the key.
             #  Note that this may not always work, but the workaround is straight forward -- set inlined_as_list to
             #  True

linkml/generators/shaclgen.py

@@ -51,12 +51,12 @@ class ShaclGenerator(Generator):
         if self.schema.version:
             print(f"# version: {self.schema.version}")
 
-    def serialize(self, **args) -> None:
+    def serialize(self, **args) -> str:
         g = self.as_graph()
         data = g.serialize(format="turtle" if self.format in ["owl", "ttl"] else self.format)
         return data
 
-    def as_graph(self) -> None:
+    def as_graph(self) -> Graph:
         sv = self.schemaview
         g = Graph()
         g.bind("sh", SH)

linkml/generators/sqlalchemygen.py

@@ -161,7 +161,7 @@ class SQLAlchemyGenerator(Generator):
             # concatenate the python dataclasses with the sqla code
             if pydantic:
                 # mixin inheritance doesn't get along with SQLAlchemy's imperative (aka classical) mapping
-                pygen = PydanticGenerator(self.original_schema, allow_extra=True, gen_mixin_inheritance=False)
+                pygen = PydanticGenerator(self.original_schema, extra_fields="allow", gen_mixin_inheritance=False)
             else:
                 pygen = PythonGenerator(self.original_schema)
             dc_code = pygen.serialize()

linkml/utils/generator.py

@@ -223,7 +223,7 @@ class Generator(metaclass=abc.ABCMeta):
         else:
             if isinstance(schema, SchemaDefinition):
                 # schemaloader based methods require schemas to have been created via SchemaLoader,
-                # which prepopulates some fields (e.g definition_url). If the schema has not been processed through the
+                # which prepopulates some fields (e.g. definition_url). If the schema has not been processed through the
                 # loader, then roundtrip
                 if any(c for c in schema.classes.values() if not c.definition_uri):
                     schema = yaml_dumper.dumps(schema)
@@ -339,11 +339,11 @@ class Generator(metaclass=abc.ABCMeta):
 
     def visit_class_slot(self, cls: ClassDefinition, aliased_slot_name: str, slot: SlotDefinition) -> None:
         """Visited for each slot in a class.  If class level visit_all_slots is true, this is visited once
-        for any class that is inherited (class itself, is_a, mixin, apply_to).  Otherwise just the own slots.
+        for any class that is inherited (class itself, is_a, mixin, apply_to).  Otherwise, just the own slots.
 
         @param cls: containing class
         @param aliased_slot_name: Aliased slot name.  May not be unique across all class slots
-        @param slot: slot being visited
+        @param slot: being visited
         """
         ...
 
@@ -758,11 +758,28 @@ class Generator(metaclass=abc.ABCMeta):
     # TODO: add lru cache once we get identity into the classes
     def domain_slots(self, cls: ClassDefinition) -> List[SlotDefinition]:
         """Return all slots in the class definition that are owned by the class"""
-        return [
-            slot
-            for slot in [self.schema.slots[sn] for sn in cls.slots]
-            if cls.name in slot.domain_of or (set(cls.mixins).intersection(slot.domain_of))
-        ]
+        domain_slots = []
+        for slot_name in cls.slots:
+            slot = self.schema.slots[slot_name]
+
+            # add any mixin ancestors here so that slots will be distributed to descendents correctly via mixin
+            # hierarchy.
+            mixin_ancestors = []
+            if cls.mixins:
+                for mixin in cls.mixins:
+                    for ancestor in self.schemaview.class_ancestors(mixin, mixins=False):
+                        if ancestor not in mixin_ancestors:
+                            mixin_ancestors.append(ancestor)
+
+            for mixin_ancestor in mixin_ancestors:
+                if mixin_ancestor not in cls.mixins:
+                    cls.mixins.append(mixin_ancestor)
+
+            # Check if the class is in the domain of the slot or if any of its mixins are in the domain
+            if cls.name in slot.domain_of or (set(cls.mixins).intersection(slot.domain_of)):
+                domain_slots.append(slot)
+
+        return domain_slots
 
     def add_mappings(self, defn: Definition) -> None:
         """

linkml/utils/schemaloader.py

@@ -691,7 +691,7 @@ class SchemaLoader:
                         cls.is_a,
                     )
             for mixin in cls.mixins:
-                # Note that apply_to has ben injected as a faux mixin so it gets covered here
+                # Note that apply_to has been injected as a faux mixin, so it gets covered here
                 if mixin in self.schema.classes:
                     self.merge_class(self.schema.classes[mixin], merged_classes)
                     merge_classes(self.schema, cls, self.schema.classes[mixin], True)

linkml/validator/validation_context.py

@@ -51,12 +51,15 @@ class ValidationContext:
         return jsonschema_gen.generate()
 
     def pydantic_model(self, *, closed: bool):
-        module = self._pydantic_module(closed)
+        module = self._pydantic_module(closed=closed)
         return module.__dict__[self._target_class]
 
     @lru_cache
-    def _pydantic_module(self, *closed: bool):
-        return PydanticGenerator(self._schema, allow_extra=not closed).compile_module()
+    def _pydantic_module(self, *, closed: bool):
+        return PydanticGenerator(
+            self._schema,
+            extra_fields="forbid" if closed else "ignore" if closed is None else "allow",
+        ).compile_module()
 
     def _get_target_class(self, target_class: Optional[str] = None) -> str:
         if target_class is None:

linkml-1.6.5.dist-info/LICENSE

@@ -0,0 +1,13 @@
+Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

{linkml-1.6.3.dist-info → linkml-1.6.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml
-Version: 1.6.3
+Version: 1.6.5
 Summary: Linked Open Data Modeling Language
 Home-page: https://linkml.io/linkml/
 Keywords: schema,linked data,data modeling,rdf,owl,biolink

{linkml-1.6.3.dist-info → linkml-1.6.5.dist-info}/RECORD

@@ -6,29 +6,29 @@ linkml/generators/__init__.py,sha256=qa22iTeBrcds6ndst_iTPVWLQtBF6NGyhVngBhbhIpc
 linkml/generators/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 linkml/generators/common/type_designators.py,sha256=lgVcIRJJ-yCvVGeP9U_gQZpm77UmJBQo9Bh3lGJITno,1956
 linkml/generators/csvgen.py,sha256=h-Mj-uNrzuETx_G3dW6eFbk1jj0NHSwqbehqR5tA6PM,2955
-linkml/generators/docgen/class.md.jinja2,sha256=r8bsve3K5jLXD-cTTiMIiOuekNJBDwYAyb-lcnOrDBk,3168
+linkml/generators/docgen/class.md.jinja2,sha256=05Kbl83ApOMzA7gZeRJjPU7jkZHCIsaKN1BYWNMRTfM,3275
 linkml/generators/docgen/class_diagram.md.jinja2,sha256=ShRhNnIae54Y_4zrfXuIF6BjX8oCHRZJnovE8G1fjOU,2542
 linkml/generators/docgen/common_metadata.md.jinja2,sha256=zy8Ua3gDtAAq8VA3e3O3ft9W7eJopVZaq5efP8LU_hU,1321
 linkml/generators/docgen/enum.md.jinja2,sha256=mXnUrRkleY2bOTEyAZ5c4pcUnqhs6BNa8a-4LVve-eo,1014
 linkml/generators/docgen/index.md.jinja2,sha256=wXUYTmayPLFltC0vbGE_Mf6m3GkkWav7FOEjCvEpHp4,1466
 linkml/generators/docgen/index.tex.jinja2,sha256=Go_EA-_N4JUpbOYbk3OY11mz5yV70VF2l2sMtgIPWw4,501
 linkml/generators/docgen/schema.md.jinja2,sha256=xlENfnzNRYgPT_0tdqNFxgklVM4Qf5BuzhFVvSMDuxs,70
-linkml/generators/docgen/slot.md.jinja2,sha256=0A5SDAW34Y9e3pMLjImWFWuMHLh53SGvdXx2XBSmEz0,2704
+linkml/generators/docgen/slot.md.jinja2,sha256=XVd0M4gKx9Q2fONcsUGBRj_bJivyN4P9jhj9IO496jQ,2817
 linkml/generators/docgen/subset.md.jinja2,sha256=fTNIpAkml5RKFbbtLore3IAzFN1cISVsyL1ru2-Z4oA,2665
 linkml/generators/docgen/type.md.jinja2,sha256=QmCMJZrFwP33eHkggBVtypbyrxTb-XZn9vHOYojVaYk,635
-linkml/generators/docgen.py,sha256=k_nRddHEaQzqYX-qNw_0cUjerW30255S2geMPf1z3PY,32504
+linkml/generators/docgen.py,sha256=zsLzbXN2t9pafQubEnb7QshufMKBMqUWjdLE1OyFyq8,33296
 linkml/generators/dotgen.py,sha256=CnbVY6CO1OMuiYXYnvxgNN2IW1mtOQW-J-QnwZlXkUI,5012
 linkml/generators/erdiagramgen.py,sha256=Gu-_nhLuEPTsYYaoV6tNS1V6cZ2dNJdm6YwxC0VGl7g,10315
-linkml/generators/excelgen.py,sha256=uFc8xOCeBhWhWdHPTepotBBaIQPtBA6MkFfVtiKWGhw,6699
+linkml/generators/excelgen.py,sha256=ClzWs3wO-QjH2XzzQVUsGF2n6fnoozmXopxPYDEJyPs,7232
 linkml/generators/golanggen.py,sha256=Dnl7dhmb1AIK3Is7KRaUbxPd3kBTjWuspFqardiBTJ8,5751
 linkml/generators/golrgen.py,sha256=tIsbsr4SM9HxeK7TCUwnq-GdSKZ_qW5f7fybg_aqCZE,3436
 linkml/generators/graphqlgen.py,sha256=6qZpI0rwg3ypsv_KrLVzXgdsJfR8LNPqgMwaRwzwnDs,2151
 linkml/generators/javagen/example_template.java.jinja2,sha256=ec4CVTv_0zS7V5Y-1E6H4lRraya10gfX7BEMBlu38X4,444
-linkml/generators/javagen/java_record_template.jinja2,sha256=yS7vKlgkHOQJfMjeziADDBCICri5JBp85BzreSp8QXw,1737
-linkml/generators/javagen.py,sha256=Byf_923aAcWhZKeuTDPIB2o6PLuMHJV5WiD_AG0t_wg,5431
+linkml/generators/javagen/java_record_template.jinja2,sha256=OQZffLSy_xR3FIhQMltvrYyVeut7l2Q-tzK7AOiVmWs,1729
+linkml/generators/javagen.py,sha256=oZfUowKnBQNdklRqOM-yKptO4Te4y4N5ItIc5jTuWKU,5427
 linkml/generators/jsonldcontextgen.py,sha256=2TUzEzFBX7wDOYJ51Kg0hp2CVXcOzJhgIbq0CrzL2oc,7832
 linkml/generators/jsonldgen.py,sha256=KQYurjqp3gI0bevjzmrw4WDEgz4Yf4o4TJfZsqK4_vs,7575
-linkml/generators/jsonschemagen.py,sha256=2SMrdqS_OazUEQtVSm8_A0FUSx4HRd_0zFhoMQa2Nak,23820
+linkml/generators/jsonschemagen.py,sha256=CWTvj7n8pWomRqeb-vmG-z99TpzzvBu0UIbBRRag4eI,23958
 linkml/generators/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 linkml/generators/linkmlgen.py,sha256=QhIPA1v2g_g5fien3ZKN-L6TkDk3t7puVFrcoEnwkwY,3540
 linkml/generators/markdowngen.py,sha256=ZPLahEPjWsrAsKq4CHbVDXeVd0n1NO-2STs068-g0Ac,32948
@@ -39,16 +39,16 @@ linkml/generators/plantumlgen.py,sha256=Vs__5x9ioiT4IBTbvZUpgT8MsYJ0amfBL64MB_nm
 linkml/generators/prefixmapgen.py,sha256=JJ7hgzuqKVfFZrbDV76Dk8dR2NHsmpp-eNUAspXkfwA,4626
 linkml/generators/projectgen.py,sha256=EVgS5bDzFTm3WAuMg3lC3rzdcaW-hgpq99qZA4nksSY,9544
 linkml/generators/protogen.py,sha256=9YfxBZkQdBWwsUbstxEUR4xRWNuAKSfz9zXPhgIYePU,2328
-linkml/generators/pydanticgen.py,sha256=xncxCk0mwkvkzyrOIwCm4DKVH34OQnqGDUtCi50ogRA,22068
-linkml/generators/pythongen.py,sha256=DBsZNa9T3fGW4Qw0_l8N72f_DeUEugvcbRN9FJLi1QM,52166
+linkml/generators/pydanticgen.py,sha256=rH__R3Pt7TKQzG2DBo1R5OehQG3FaBMCjXBzZlAWMqw,23742
+linkml/generators/pythongen.py,sha256=7XNlOpScOOpxpo9Q_sasDOZFYaKifbXWQL-OKczpkfY,52327
 linkml/generators/rdfgen.py,sha256=LxzYBaFEkV7rlf54nWv_6H6AGcWMRXwkaeVXq9VYEc8,2693
-linkml/generators/shaclgen.py,sha256=CRmIv0hYAFY3Z2tnNcQSq6yJeNkoGn9vqx6s2r6kc8c,8662
+linkml/generators/shaclgen.py,sha256=KxNmDZW2ciCuSqUhJ65TxLTjF8jME1FmN5SaWJCuW9k,8662
 linkml/generators/shexgen.py,sha256=Awtn5SyjS-TUcVCwMdT0F7hNO4K8VcSCYBaFru45Mwg,8994
 linkml/generators/sparqlgen.py,sha256=xIT4abjYTjPvAjczZ2mkqfap5z8-AImK_jaCvgZyRGs,6120
 linkml/generators/sqlalchemy/__init__.py,sha256=mb9AC1rIFkSiNZhhG0TAk45ol9PjS1XvsrvCjgfVUpQ,249
 linkml/generators/sqlalchemy/sqlalchemy_declarative_template.py,sha256=X_Ws1NUBikMI5HuNgEhl_PIeWM-B-c2B0W9KUBH4QTg,2542
 linkml/generators/sqlalchemy/sqlalchemy_imperative_template.py,sha256=u4ZpponG1h6XROrOHGOf_0H2e6xL1_s8twAOA-gx94A,1622
-linkml/generators/sqlalchemygen.py,sha256=W5BJE-PU7kOaWtfwZw8fjyx9E_-ZQGZl1xBkywSpMCY,9182
+linkml/generators/sqlalchemygen.py,sha256=XjvyCYr9h0EsFaKy4y-lMXunYw4dnk9vSpwlPjZK8gU,9186
 linkml/generators/sqlddlgen.py,sha256=t7U0-ZOWnulA7CMrlaih73H7fQdaGNRhdVLmvWGxFT4,18436
 linkml/generators/sqltablegen.py,sha256=h_zVuNC8huRzzTa9nSHNWBxq-4TuLq7nR5nZfpDnWiM,11481
 linkml/generators/sssomgen.py,sha256=yur3q7so9uwIELWZaZRzkJwNbz_ppBL7IQki9XLIM3k,6879
@@ -86,7 +86,7 @@ linkml/utils/converter.py,sha256=rdhCI7Tsjddr3o1rVBfMq5gQubk_GE6fqlBBmyxI5_M,627
 linkml/utils/datautils.py,sha256=2XWM9LBSVp8v3SwIZECrX3SjDUYzdnP-syjp6YdL89E,3734
 linkml/utils/datavalidator.py,sha256=kBdWaVi8IZT1bOwEJgJYx-wZAb_PTBObB9nHpYORfKA,472
 linkml/utils/execute_tutorial.py,sha256=T4kHTSyz3ItJGEUZxVjR-3yLVKnOr5Ix4NMGE47-IuE,6912
-linkml/utils/generator.py,sha256=74g3s5FVpOqfOtkMTrpk0k95ny2-kSFc0AvcSlKgka0,38320
+linkml/utils/generator.py,sha256=dW9kfVL-7an0ieXR5HLe8bqOyEgDGAoIzdLOu_TFQhc,39101
 linkml/utils/helpers.py,sha256=yR8n4zFA5wPcYC7xzRuNF3wO16vG80v6j7DM3qTNmIc,447
 linkml/utils/ifabsent_functions.py,sha256=FZwceqwlq81lMPDsdNfSHhtzDXSf8F4cbbhRdnDzjss,5765
 linkml/utils/logictools.py,sha256=GSmBiobC49TcQjE08RtXEE3JwJEOV7eEREio25uJiFs,21184
@@ -94,7 +94,7 @@ linkml/utils/mergeutils.py,sha256=QVm2iQB4v_L2rSvPBsPe9C865R03BgV3TzlPoTTTwWQ,90
 linkml/utils/rawloader.py,sha256=QB7Rdvy4o4ZJEWBWa2_2xzz2TOh_6Oe4slvUn8IBVIc,4329
 linkml/utils/schema_builder.py,sha256=WLSit3J4lTifaFLLWTwjqIRiTru1pqvTIUuC1TrxS6Y,9902
 linkml/utils/schema_fixer.py,sha256=rjwJB5ukfrgc0Z-j3mKSNzRMkHPp_k_zFKaFNIPeIv8,15086
-linkml/utils/schemaloader.py,sha256=Ju1QCJPdNbLkXzTyvXmv7Bpk6EQ07Hzh7qgeYdiyTU8,46419
+linkml/utils/schemaloader.py,sha256=bBSTqimMDTFH2FcKtRz99dKNJzV_myPsZSkIFp_6-A0,46421
 linkml/utils/schemasynopsis.py,sha256=6NKa89bkZfZQE9QM0St-6xQcrsHPkYmBgnnWnlgAcQ4,18455
 linkml/utils/sqlutils.py,sha256=86XeEbfY0Dk-EObw4q5-dxyzSeBtmIhjqqyDcR8ALS0,16591
 linkml/utils/typereferences.py,sha256=8Yfuz9-HAwOPoJLbIcO_sY9zf32hvPRzGeSOzECfMWA,2232
@@ -113,7 +113,7 @@ linkml/validator/plugins/pydantic_validation_plugin.py,sha256=C-Vp74bz5oqp5V-iuh
 linkml/validator/plugins/recommended_slots_plugin.py,sha256=kOdoYQyye47nLA7BjorVmydS84nGpiVy3MoCbPq1Ymo,2308
 linkml/validator/plugins/validation_plugin.py,sha256=9SMHF8b2bgG9-8351e8bY676e0A4aEBJSXvMjMF5kXg,1548
 linkml/validator/report.py,sha256=kkkuh-IZF9--cO-2wGjwP3PDLvOcjjvC8AOlxXUIOAM,870
-linkml/validator/validation_context.py,sha256=dDMXCw6TdJC--bu53sb6-v8ch36rGeGbOndoUJXgXVw,2290
+linkml/validator/validation_context.py,sha256=MmOwLk4cF_Cy7fPdFK61Eti3c3dgzKSIu6r_PmkkoZs,2388
 linkml/validator/validator.py,sha256=jOSdYyC8QIm1GWmllM7Z1_GV-2VO3hwEwdF2AHE-DNY,5476
 linkml/validators/__init__.py,sha256=43W3J5NPKhwa3ZFHLRYsJMocwQKWGYCF9Ki9r0ccGbc,202
 linkml/validators/jsonschemavalidator.py,sha256=_v0finzU2RGPC5xo0CylYge9XkY7oAigcly2SKLwFuI,7865
@@ -123,8 +123,8 @@ linkml/workspaces/datamodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 linkml/workspaces/datamodel/workspaces.py,sha256=4HdkqweGNfMPqnB1_Onc9DcTfkhoagTRcqruh08nRoI,14905
 linkml/workspaces/datamodel/workspaces.yaml,sha256=EjVrwPpeRZqJRjuGyyDRxxFzuv55SiLIXPBRUG6HStU,4233
 linkml/workspaces/example_runner.py,sha256=hblnsZVntuwFO4vqcwl_K5XH6jxb52xCtvdc7Sfq_Yc,11452
-linkml-1.6.3.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-linkml-1.6.3.dist-info/LICENSE,sha256=Nv_Z3AhdUpp-YOEnbXOuWgMLAgMT5sVAhZOmrirzlnM,6555
-linkml-1.6.3.dist-info/entry_points.txt,sha256=za8r49Z5gcz3rAYTZLbxw5EPZr1rGuxSe1uiRUpf8R0,2143
-linkml-1.6.3.dist-info/METADATA,sha256=lRpwApDha7rSgAHvnFPHBIJtLdFO2sI1uWodl36w42U,3496
-linkml-1.6.3.dist-info/RECORD,,
+linkml-1.6.5.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+linkml-1.6.5.dist-info/LICENSE,sha256=kORMoywK6j9_iy0UvLR-a80P1Rvc9AOM4gsKlUNZABg,535
+linkml-1.6.5.dist-info/METADATA,sha256=dB0BnsijpuHie4nRiNeQ2N5mLQrr0pCu_6msKi2eWZo,3496
+linkml-1.6.5.dist-info/entry_points.txt,sha256=za8r49Z5gcz3rAYTZLbxw5EPZr1rGuxSe1uiRUpf8R0,2143
+linkml-1.6.5.dist-info/RECORD,,

linkml-1.6.3.dist-info/LICENSE

@@ -1,116 +0,0 @@
-CC0 1.0 Universal
-
-Statement of Purpose
-
-The laws of most jurisdictions throughout the world automatically confer
-exclusive Copyright and Related Rights (defined below) upon the creator and
-subsequent owner(s) (each and all, an "owner") of an original work of
-authorship and/or a database (each, a "Work").
-
-Certain owners wish to permanently relinquish those rights to a Work for the
-purpose of contributing to a commons of creative, cultural and scientific
-works ("Commons") that the public can reliably and without fear of later
-claims of infringement build upon, modify, incorporate in other works, reuse
-and redistribute as freely as possible in any form whatsoever and for any
-purposes, including without limitation commercial purposes. These owners may
-contribute to the Commons to promote the ideal of a free culture and the
-further production of creative, cultural and scientific works, or to gain
-reputation or greater distribution for their Work in part through the use and
-efforts of others.
-
-For these and/or other purposes and motivations, and without any expectation
-of additional consideration or compensation, the person associating CC0 with a
-Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
-and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
-and publicly distribute the Work under its terms, with knowledge of his or her
-Copyright and Related Rights in the Work and the meaning and intended legal
-effect of CC0 on those rights.
-
-1. Copyright and Related Rights. A Work made available under CC0 may be
-protected by copyright and related or neighboring rights ("Copyright and
-Related Rights"). Copyright and Related Rights include, but are not limited
-to, the following:
-
-  i. the right to reproduce, adapt, distribute, perform, display, communicate,
-  and translate a Work;
-
-  ii. moral rights retained by the original author(s) and/or performer(s);
-
-  iii. publicity and privacy rights pertaining to a person's image or likeness
-  depicted in a Work;
-
-  iv. rights protecting against unfair competition in regards to a Work,
-  subject to the limitations in paragraph 4(a), below;
-
-  v. rights protecting the extraction, dissemination, use and reuse of data in
-  a Work;
-
-  vi. database rights (such as those arising under Directive 96/9/EC of the
-  European Parliament and of the Council of 11 March 1996 on the legal
-  protection of databases, and under any national implementation thereof,
-  including any amended or successor version of such directive); and
-
-  vii. other similar, equivalent or corresponding rights throughout the world
-  based on applicable law or treaty, and any national implementations thereof.
-
-2. Waiver. To the greatest extent permitted by, but not in contravention of,
-applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
-unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
-and Related Rights and associated claims and causes of action, whether now
-known or unknown (including existing as well as future claims and causes of
-action), in the Work (i) in all territories worldwide, (ii) for the maximum
-duration provided by applicable law or treaty (including future time
-extensions), (iii) in any current or future medium and for any number of
-copies, and (iv) for any purpose whatsoever, including without limitation
-commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes
-the Waiver for the benefit of each member of the public at large and to the
-detriment of Affirmer's heirs and successors, fully intending that such Waiver
-shall not be subject to revocation, rescission, cancellation, termination, or
-any other legal or equitable action to disrupt the quiet enjoyment of the Work
-by the public as contemplated by Affirmer's express Statement of Purpose.
-
-3. Public License Fallback. Should any part of the Waiver for any reason be
-judged legally invalid or ineffective under applicable law, then the Waiver
-shall be preserved to the maximum extent permitted taking into account
-Affirmer's express Statement of Purpose. In addition, to the extent the Waiver
-is so judged Affirmer hereby grants to each affected person a royalty-free,
-non transferable, non sublicensable, non exclusive, irrevocable and
-unconditional license to exercise Affirmer's Copyright and Related Rights in
-the Work (i) in all territories worldwide, (ii) for the maximum duration
-provided by applicable law or treaty (including future time extensions), (iii)
-in any current or future medium and for any number of copies, and (iv) for any
-purpose whatsoever, including without limitation commercial, advertising or
-promotional purposes (the "License"). The License shall be deemed effective as
-of the date CC0 was applied by Affirmer to the Work. Should any part of the
-License for any reason be judged legally invalid or ineffective under
-applicable law, such partial invalidity or ineffectiveness shall not
-invalidate the remainder of the License, and in such case Affirmer hereby
-affirms that he or she will not (i) exercise any of his or her remaining
-Copyright and Related Rights in the Work or (ii) assert any associated claims
-and causes of action with respect to the Work, in either case contrary to
-Affirmer's express Statement of Purpose.
-
-4. Limitations and Disclaimers.
-
-  a. No trademark or patent rights held by Affirmer are waived, abandoned,
-  surrendered, licensed or otherwise affected by this document.
-
-  b. Affirmer offers the Work as-is and makes no representations or warranties
-  of any kind concerning the Work, express, implied, statutory or otherwise,
-  including without limitation warranties of title, merchantability, fitness
-  for a particular purpose, non infringement, or the absence of latent or
-  other defects, accuracy, or the present or absence of errors, whether or not
-  discoverable, all to the greatest extent permissible under applicable law.
-
-  c. Affirmer disclaims responsibility for clearing rights of other persons
-  that may apply to the Work or any use thereof, including without limitation
-  any person's Copyright and Related Rights in the Work. Further, Affirmer
-  disclaims responsibility for obtaining any necessary consents, permissions
-  or other rights required for any use of the Work.
-
-  d. Affirmer understands and acknowledges that Creative Commons is not a
-  party to this document and has no duty or obligation with respect to this
-  CC0 or use of the Work.
-
-For more information, please see
-<http://creativecommons.org/publicdomain/zero/1.0/>