more jsonschema export

Summary

Mostly ui schema.

Focus

Are the tests sufficient?

Test Environment

Look at tests. If you want to, copy&past the json to https://rjsf-team.github.io/react-jsonschema-form/

Check List for the Author

Please, prepare your MR for a review. Be sure to write a summary and a focus and create gitlab comments for the reviewer. They should guide the reviewer through the changes, explain your changes and also point out open questions. For further good practices have a look at our review guidelines

• All automated tests pass
• Reference related issues caosdb/customers/dimr/management#58
• Up-to-date CHANGELOG.md (or not necessary)
• Up-to-date JSON schema (or not necessary)
• Appropriate user and developer documentation (or not necessary)
  • How do I use the software? Assume "stupid" users.
  • How do I develop or debug the software? Assume novice developers.
• Annotations in code (Gitlab comments)
  • Intent of new code
  • Problems with old code
  • Why this implementation?

Check List for the Reviewer

• I understand the intent of this MR
• All automated tests pass
• Up-to-date CHANGELOG.md (or not necessary)
• Appropriate user and developer documentation (or not necessary)
• The test environment setup works and the intended behavior is reproducible in the test environment
• In-code documentation and comments are up-to-date.
• Check: Are there specifications? Are they satisfied?

For further good practices have a look at our review guidelines.

src/caosadvancedtools/json_schema_exporter.py

@@ -25,7 +25,7 @@ The scope of this json schema is the automatic generation of user interfaces.
 """
 
 from collections import OrderedDict
-from typing import Any, Dict, Iterable, List, Optional, Union
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple, Union
 
 import linkahead as db
 from linkahead.common.datatype import get_list_datatype, is_list_datatype
@@ -43,6 +43,7 @@ class JsonSchemaExporter:
                  do_not_create: List[str] = None,
                  do_not_retrieve: List[str] = None,
                  no_remote: bool = False,
+                 multiple_choice: List[str] = None,
                  ):
         """Set up a JsonSchemaExporter, which can then be applied on RecordTypes.
 
@@ -75,6 +76,10 @@ class JsonSchemaExporter:
             parameter, the behavior is undefined.
         no_remote : bool
             If True, do not attempt to connect to a LinkAhead server at all. Default is False.
+        multiple_choice : list[str], optional
+            A list of reference Property names which shall be denoted as multiple choice properties.
+            This means that each option in this property may be selected at most once.  This is not
+            implemented yet if the Property is not in ``do_not_create`` as well.
         """
         if not additional_options_for_text_props:
             additional_options_for_text_props = {}
@@ -82,6 +87,8 @@ class JsonSchemaExporter:
             do_not_create = []
         if not do_not_retrieve:
             do_not_retrieve = []
+        if not multiple_choice:
+            multiple_choice = []
 
         self._additional_properties = additional_properties
         self._name_property_for_new_records = name_property_for_new_records
@@ -91,6 +98,7 @@ class JsonSchemaExporter:
         self._do_not_create = do_not_create
         self._do_not_retrieve = do_not_retrieve
         self._no_remote = no_remote
+        self._multiple_choice = multiple_choice
 
     @staticmethod
     def _make_required_list(rt: db.RecordType):
@@ -106,15 +114,15 @@ class JsonSchemaExporter:
 
         return required_list
 
-    def _make_segment_from_prop(self, prop: db.Property):
-        """Return the JSON Schema segment for the given property
+    def _make_segment_from_prop(self, prop: db.Property) -> Tuple[OrderedDict, dict]:
+        """Return the JSON Schema and ui schema segments for the given property.
 
         Parameters
         ----------
         prop : db.Property
             The property to be transformed.
         """
-
+        ui_schema: dict = {}
         if prop.datatype == db.TEXT or prop.datatype == db.DATETIME:
             text_format = None
             text_pattern = None
@@ -131,7 +139,7 @@ class JsonSchemaExporter:
                 # options list.
                 text_format = ["date", "date-time"]
 
-            return self._make_text_property(prop.description, text_format, text_pattern)
+            return self._make_text_property(prop.description, text_format, text_pattern), ui_schema
 
         json_prop = OrderedDict()
         if prop.description:
@@ -154,13 +162,21 @@ class JsonSchemaExporter:
             json_prop["type"] = "array"
             list_element_prop = db.Property(
                 name=prop.name, datatype=get_list_datatype(prop.datatype, strict=True))
-            json_prop["items"] = self._make_segment_from_prop(list_element_prop)
+            json_prop["items"], inner_ui_schema = self._make_segment_from_prop(list_element_prop)
+            if prop.name in self._multiple_choice and prop.name in self._do_not_create:
+                json_prop["uniqueItems"] = True
+                ui_schema["ui:widget"] = "checkboxes"
+                ui_schema["ui:options"] = {"inline": True}
+            if inner_ui_schema:
+                ui_schema["items"] = inner_ui_schema
         elif prop.is_reference():
             if prop.datatype == db.REFERENCE:
                 # No Record creation since no RT is specified and we don't know what
                 # schema to use, so only enum of all Records and all Files.
                 values = self._retrieve_enum_values("RECORD") + self._retrieve_enum_values("FILE")
                 json_prop["enum"] = values
+                if prop.name in self._multiple_choice:
+                    json_prop["uniqueItems"] = True
             elif prop.datatype == db.FILE:
                 json_prop["type"] = "string"
                 json_prop["format"] = "data-url"
@@ -181,7 +197,9 @@ class JsonSchemaExporter:
                     else:
                         rt = db.execute_query(f"FIND RECORDTYPE WITH name='{prop_name}'",
                                               unique=True)
-                    subschema = self._make_segment_from_recordtype(rt)
+                    subschema, ui_schema = self._make_segment_from_recordtype(rt)
+                    # if inner_ui_schema:
+                    #     ui_schema = inner_ui_schema
                     if values:
                         subschema["title"] = "Create new"
                         json_prop["oneOf"] = [
@@ -198,7 +216,7 @@ class JsonSchemaExporter:
             raise ValueError(
                 f"Unknown or no property datatype. Property {prop.name} with type {prop.datatype}")
 
-        return json_prop
+        return json_prop, ui_schema
 
     @staticmethod
     def _make_text_property(description="", text_format=None, text_pattern=None):
@@ -239,22 +257,26 @@ class JsonSchemaExporter:
         vals = []
         for val in possible_values:
             if val.name:
-                vals.append(f"{val.id}, {val.name}")
+                vals.append(f"{val.name}")
             else:
                 vals.append(f"{val.id}")
 
         return vals
 
-    def _make_segment_from_recordtype(self, rt: db.RecordType):
-        """Return a Json schema segment for the given RecordType.
+    def _make_segment_from_recordtype(self, rt: db.RecordType) -> Tuple[OrderedDict, dict]:
+        """Return Json schema and uischema segments for the given RecordType.
         """
-        schema: dict[str, Any] = {
+        schema: OrderedDict[str, Any] = OrderedDict({
             "type": "object"
-        }
+        })
+        ui_schema = {}
 
         schema["required"] = self._make_required_list(rt)
         schema["additionalProperties"] = self._additional_properties
 
+        if rt.name:
+            schema["title"] = rt.name
+
         props = OrderedDict()
         if self._name_property_for_new_records:
             props["name"] = self._make_text_property("The name of the Record to be created")
@@ -269,13 +291,16 @@ class JsonSchemaExporter:
                     "Creating a schema for multi-properties is not specified. "
                     f"Property {prop.name} occurs more than once."
                 )
-            props[prop.name] = self._make_segment_from_prop(prop)
+            props[prop.name], inner_ui_schema = self._make_segment_from_prop(prop)
+            if inner_ui_schema:
+                ui_schema[prop.name] = inner_ui_schema
 
         schema["properties"] = props
 
-        return schema
+        return schema, ui_schema
 
-    def recordtype_to_json_schema(self, rt: db.RecordType):
+    def recordtype_to_json_schema(self, rt: db.RecordType, rjsf: bool = False) -> Union[
+            dict, Tuple[dict, dict]]:
         """Create a jsonschema from a given RecordType that can be used, e.g., to
         validate a json specifying a record of the given type.
 
@@ -283,22 +308,31 @@ class JsonSchemaExporter:
         ----------
         rt : RecordType
             The RecordType from which a json schema will be created.
+        rjsf : bool, optional
+            If True, uiSchema definitions for react-jsonschema-forms will be output as the second
+            return value.  Default is False
 
         Returns
         -------
         schema : dict
             A dict containing the json schema created from the given RecordType's properties.
+
+        ui_schema : dict, optional
+            A ui schema.  Only if a parameter asks for it (e.g. ``rjsf``).
         """
         if rt is None:
             raise ValueError(
                 "recordtype_to_json_schema(...) cannot be called with a `None` RecordType.")
-        schema = self._make_segment_from_recordtype(rt)
-        schema["$schema"] = "https://json-schema.org/draft/2019-09/schema"
-        if rt.name:
-            schema["title"] = rt.name
+        schema, inner_uischema = self._make_segment_from_recordtype(rt)
+        schema["$schema"] = "https://json-schema.org/draft/2020-12/schema"
         if rt.description:
             schema["description"] = rt.description
 
+        if rjsf:
+            uischema = {}
+            if inner_uischema:
+                uischema = inner_uischema
+            return schema, uischema
         return schema
 
 
@@ -310,7 +344,9 @@ def recordtype_to_json_schema(rt: db.RecordType, additional_properties: bool = T
                               do_not_create: List[str] = None,
                               do_not_retrieve: List[str] = None,
                               no_remote: bool = False,
-                              ):
+                              multiple_choice: List[str] = None,
+                              rjsf: bool = False,
+                              ) -> Union[dict, Tuple[dict, dict]]:
     """Create a jsonschema from a given RecordType that can be used, e.g., to
     validate a json specifying a record of the given type.
 
@@ -338,22 +374,31 @@ def recordtype_to_json_schema(rt: db.RecordType, additional_properties: bool = T
         description of the corresponding schema entry. If set to false, an
         additional `unit` key is added to the schema itself which is purely
         annotational and ignored, e.g., in validation. Default is True.
-    do_not_create : list[str]
+    do_not_create : list[str], optional
         A list of RedcordType names, for which there should be no option
         to create them.  Instead, only the choice of existing elements should
         be given.
-    do_not_retrieve : list[str]
+    do_not_retrieve : list[str], optional
         A list of RedcordType names, for which no Records shall be retrieved.  Instead, only an
         object description should be given.  If this list overlaps with the `do_not_create`
         parameter, the behavior is undefined.
-    no_remote : bool
+    no_remote : bool, optional
         If True, do not attempt to connect to a LinkAhead server at all.  Default is False.
+    multiple_choice : list[str], optional
+        A list of reference Property names which shall be denoted as multiple choice properties.
+        This means that each option in this property may be selected at most once.  This is not
+        implemented yet if the Property is not in ``do_not_create`` as well.
+    rjsf : bool, optional
+        If True, uiSchema definitions for react-jsonschema-forms will be output as the second return
+        value.  Default is False.
 
     Returns
     -------
     schema : dict
         A dict containing the json schema created from the given RecordType's properties.
 
+    ui_schema : dict, optional
+        A ui schema.  Only if a parameter asks for it (e.g. ``rjsf``).
     """
 
     exporter = JsonSchemaExporter(
@@ -365,11 +410,12 @@ def recordtype_to_json_schema(rt: db.RecordType, additional_properties: bool = T
         do_not_create=do_not_create,
         do_not_retrieve=do_not_retrieve,
         no_remote=no_remote,
+        multiple_choice=multiple_choice,
     )
-    return exporter.recordtype_to_json_schema(rt)
+    return exporter.recordtype_to_json_schema(rt, rjsf=rjsf)
 
 
-def make_array(schema: dict) -> dict:
+def make_array(schema: dict, rjsf_uischema: dict = None) -> Union[dict, Tuple[dict, dict]]:
     """Create an array of the given schema.
 
 The result will look like this:
@@ -388,21 +434,33 @@ Parameters
 schema : dict
   The JSON schema which shall be packed into an array.
 
+rjsf_uischema : dict, optional
+  A react-jsonschema-forms ui schema that shall be wrapped as well.
+
 Returns
 -------
 
-out : dict
+schema : dict
   A JSON schema dict with a top-level array which contains instances of the given schema.
+
+ui_schema : dict, optional
+  The wrapped ui schema.  Only returned if ``rjsf_uischema`` is given as parameter.
     """
     result = {
         "type": "array",
         "items": schema,
-        "$schema": "https://json-schema.org/draft/2019-09/schema",
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
     }
+
+    if rjsf_uischema is not None:
+        ui_schema = {"items": rjsf_uischema}
+        return result, ui_schema
     return result
 
 
-def merge_schemas(schemas: Union[Dict[str, dict], Iterable[dict]]) -> dict:
+def merge_schemas(schemas: Union[Dict[str, dict], Iterable[dict]],
+                  rjsf_uischemas: Union[Dict[str, dict], Sequence[dict]] = None) -> (
+                      Union[dict, Tuple[dict, dict]]):
     """Merge the given schemata into a single schema.
 
 The result will look like this:
@@ -429,24 +487,45 @@ schemas : dict[str, dict] | Iterable[dict]
   be used as property names, otherwise the titles of the submitted schemata.  If they have no title,
   numbers will be used as a fallback.  Note that even with a dict, the original schema's "title" is
   not changed.
+rjsf_uischemas : dict[str, dict] | Iterable[dict], optional
+  If given, also merge the react-jsonschema-forms from this argument and return as the second return
+  value.  If ``schemas`` is a dict, this parameter must also be a dict, if ``schemas`` is only an
+  iterable, this paramater must support numerical indexing.
 
 Returns
 -------
 
-out : dict
+schema : dict
   A JSON schema dict with a top-level object which contains the given schemata as properties.
+
+uischema : dict
+  If ``rjsf_uischemas`` was given, this contains the merged UI schemata.
     """
     sub_schemas: dict[str, dict] = OrderedDict()
     required = []
+    ui_schema = None
 
     if isinstance(schemas, dict):
         sub_schemas = schemas
         required = [str(k) for k in schemas.keys()]
+        if rjsf_uischemas is not None:
+            if not isinstance(rjsf_uischemas, dict):
+                raise ValueError("Parameter `rjsf_uischemas` must be a dict, because `schemas` is "
+                                 f"as well, but it is a {type(rjsf_uischemas)}.")
+            ui_schema = {k: rjsf_uischemas[k] for k in schemas.keys()}
     else:
         for i, schema in enumerate(schemas, start=1):
             title = schema.get("title", str(i))
             sub_schemas[title] = schema
             required.append(title)
+        if rjsf_uischemas is not None:
+            if not isinstance(rjsf_uischemas, Sequence):
+                raise ValueError("Parameter `rjsf_uischemas` must be a sequence, because `schemas` "
+                                 f"is as well, but it is a {type(rjsf_uischemas)}.")
+            ui_schema = {}
+            for i, title in enumerate(sub_schemas.keys()):
+                ui_schema[title] = rjsf_uischemas[i]
+            # ui_schema = {"index": ui_schema}
 
     result = {
         "type": "object",
@@ -456,4 +535,6 @@ out : dict
         "$schema": "https://json-schema.org/draft/2020-12/schema",
     }
 
+    if ui_schema is not None:
+        return result, ui_schema
     return result