AP-23472: Fetch type names of LogicalTypes unknown to Python from Java

Author: black-tea-lover

org.knime.python3.arrow.tests/src/test/python/unittest/test_pandas_extension_type.py

@@ -788,13 +788,7 @@ def test_timestamp_columns(self):
             )  # drop index as it messes up equality
 
             arrow_table = arrow_backend.write_table(df)
-            knime_ts_ext_str = (
-                "extension<logical={"
-                '"value_factory_class":"org.knime.core.data.v2.value.cell.DictEncodedDataCellValueFactory",'
-                '"data_type":{"cell_class":"org.knime.core.data.date.DateAndTimeCell"}}, '
-                "storage=struct<extension<logical=structDictEncoded, storage=blob>, "
-                "extension<logical=structDictEncoded, storage=string>>>"
-            )
+            knime_ts_ext_str = "Timestamp"
 
             self.assertEqual(
                 "<class 'knime.scripting._deprecated._arrow_table.ArrowWriteTable'>",

org.knime.python3.nodes.tests/src/test/python/unittest/test_utilities.py

@@ -42,8 +42,33 @@ def gateway_property(self):
 
     @property
     def jvm(self):
+        def _getTypeNameForLogicalTypeString(logical_type: str):
+            if (
+                logical_type
+                == '{"value_factory_class":"org.knime.core.data.v2.value.cell.DictEncodedDataCellValueFactory","data_type":{"cell_class":"org.knime.core.data.uri.URIDataCell"}}'
+            ):
+                return "URI"
+            elif (
+                logical_type
+                == '{"value_factory_class": "org.knime.core.data.v2.value.StringSetValueFactory"}'
+            ):
+                return "Set (Collection of: String)"
+            elif (
+                logical_type
+                == '{"value_factory_class":"org.knime.core.data.v2.value.SetValueFactory"}'
+            ):
+                return "Set"
+            elif (
+                logical_type
+                == '{"value_factory_class":"org.knime.core.data.v2.value.cell.DictEncodedDataCellValueFactory","data_type":{"cell_class":"org.knime.core.data.date.DateAndTimeCell"}}'
+            ):
+                return "Timestamp"
+            else:
+                raise ValueError()
+
         mock = MagicMock()
         mock.org = MagicMock()
+        mock.org.knime.core.data.v2.ValueFactoryUtils.getTypeNameForLogicalTypeString = _getTypeNameForLogicalTypeString
         return mock
 
 

org.knime.python3.tests/src/test/python/unittest/test_knime_schema.py

@@ -547,6 +547,54 @@ def test_to_str(self):
             f"Schema<\n\t{sep.join(str(k.Column(t, n, None)) for t, n in zip(types, names))}>",
         )
 
+    def test_logical_type_to_str(self):
+        """Tests the string representation of LogicalTypes. Fetching types from the gateway (when no
+        PythonValueFactory is registered) is mocked, so this test validates the recursive logic of handling
+        LogicalTypes that are collections instead of validating for each type whether the gateway call returns
+        the correct type name."""
+        # Registered PythonValueFactory
+
+        datetime_type = k.logical(dt.datetime)
+        datetime_repr = "Local Date and Time"
+        self.assertEqual(str(datetime_type), datetime_repr)
+
+        datetime_list_type = k.ListType(k.logical(dt.datetime))
+        datetime_list_repr = "List (Collection of: Local Date and Time)"
+        self.assertEqual(str(datetime_list_type), datetime_list_repr)
+
+        # PythonValueFactory not registered and storage_type has no inner_type
+
+        uri_type = k.LogicalType(
+            '{"value_factory_class":"org.knime.core.data.v2.value.cell.DictEncodedDataCellValueFactory",'
+            '"data_type":{"cell_class":"org.knime.core.data.uri.URIDataCell"}}',
+            None,  # omitted because only relevant if type is a collection
+        )
+        uri_repr = "URI"
+        self.assertEqual(str(uri_type), uri_repr)
+
+        string_set_type = k.LogicalType(
+            '{"value_factory_class": "org.knime.core.data.v2.value.StringSetValueFactory"}',
+            None,
+        )
+        string_set_repr = "Set (Collection of: String)"
+        self.assertEqual(str(string_set_type), string_set_repr)
+
+        # PythonValueFactory not registered and storage_type has inner_type (LogicalType is a collection)
+
+        timestamp_set_storage_type = k.ListType(
+            k.LogicalType(
+                '{"value_factory_class":"org.knime.core.data.v2.value.cell.DictEncodedDataCellValueFactory",'
+                '"data_type":{"cell_class":"org.knime.core.data.date.DateAndTimeCell"}}',
+                None,
+            )
+        )
+        timestamp_set_type = k.LogicalType(
+            '{"value_factory_class":"org.knime.core.data.v2.value.SetValueFactory"}',
+            timestamp_set_storage_type,
+        )
+        string_timestamp_set_repr = "Set (Collection of: Timestamp)"
+        self.assertEqual(str(timestamp_set_type), string_timestamp_set_repr)
+
     def test_logical_type_wrapping(self):
         types = [
             k.int32(),

org.knime.python3/src/main/python/knime/api/schema.py

@@ -386,6 +386,26 @@ def __str__(self) -> str:
                 self.logical_type
             )
         except ValueError:
+            # try to get the type from Java
+            import knime._backend._gateway as kg
+
+            if kg.client_server != null:
+                try:
+                    type_name = kg.client_server.jvm.org.knime.core.data.v2.ValueFactoryUtils.getTypeNameForLogicalTypeString(
+                        self.logical_type
+                    )
+
+                    # we might want to cache these
+
+                    # if the logical type is a collection, we also extract the inner type
+                    if hasattr(self.storage_type, "inner_type"):
+                        inner_type = str(self.storage_type.inner_type)
+                        return type_name + " (Collection of: " + inner_type + ")"
+                    else:
+                        return type_name
+                except Exception:
+                    pass
+
             return (
                 f"extension<logical={self.logical_type}, storage={self.storage_type}>"
             )