Update Python formatting with ruff 0.9.3

Author: HedgehogCode

org.knime.python3.arrow.tests/src/test/python/tests_launcher.py

@@ -281,15 +281,15 @@ def assert_value(r, b, v):
 
             elif data_type == "float":
                 # Compare with epsilon
-                assert (
-                    abs(v.as_py() - expected) < FLOAT_COMPARISON_EPSILON
-                ), wrong_value_message(r, b, expected, v)
+                assert abs(v.as_py() - expected) < FLOAT_COMPARISON_EPSILON, (
+                    wrong_value_message(r, b, expected, v)
+                )
 
             elif data_type == "double":
                 # Compare with epsilon
-                assert (
-                    abs(v.as_py() - expected) < DOUBLE_COMPARISON_EPSILON
-                ), wrong_value_message(r, b, expected, v)
+                assert abs(v.as_py() - expected) < DOUBLE_COMPARISON_EPSILON, (
+                    wrong_value_message(r, b, expected, v)
+                )
 
             elif data_type in ["localdatetime", "localtime"]:
                 # We do not compare python values but arrow values for them
@@ -315,22 +315,22 @@ def check_batch(batch, b):
             array = batch.column(0)
 
             # Check length
-            assert (
-                len(array) == NUM_ROWS
-            ), f"Array has the wrong length. Expected {NUM_ROWS} got {len(array)}."
+            assert len(array) == NUM_ROWS, (
+                f"Array has the wrong length. Expected {NUM_ROWS} got {len(array)}."
+            )
             # Check array type
-            assert isinstance(
-                array, expected_array_type
-            ), f"Array has wrong type. Expected '{expected_array_type}', got '{type(array)}'."
+            assert isinstance(array, expected_array_type), (
+                f"Array has wrong type. Expected '{expected_array_type}', got '{type(array)}'."
+            )
             for r, v in enumerate(array):
                 if r % 13 == 0:
                     # Check that every 13th value is missing
                     assert v.as_py() is None, wrong_value_message(r, b, None, v)
                 else:
                     # Check value type
-                    assert (
-                        v.type == expected_value_type
-                    ), f"Value has wrong type. Expected '{expected_value_type}', got '{v.type}'"
+                    assert v.type == expected_value_type, (
+                        f"Value has wrong type. Expected '{expected_value_type}', got '{v.type}'"
+                    )
                     # Check value
                     assert_value(r, b, v)
 

org.knime.python3.arrow.types.tests/src/test/python/extension_tests_launcher.py

@@ -103,21 +103,21 @@ def assertIntListEquals(self, data_source, a, b, c, d, e):
             py_array = array.to_pylist()
             values = [[a, b, c, d, e]]
 
-            assert (
-                py_array == values
-            ), f"Wrong list of ints, expected '{values}' got '{py_array}'"
-            assert (
-                pd_array.shape == (1,)
-            ), f"Wrong shape returned from pandas, expected '(1,)', got '{pd_array.shape}'"
-            assert (
-                type(pd_array[0]) == np.ndarray
-            ), f"Wrong type returned from pandas, expected 'numpy.ndarray' got '{type(pd_array[0])}'"
-            assert (
-                len(pd_array[0]) == 5
-            ), f"Wrong length of list returned from pandas, expected '5', got '{len(pd_array[0])}'"
-            assert np.all(
-                pd_array[0] == values[0]
-            ), f"Wrong list of ints returned from pandas, expected '{values}' got '{pd_array[0]}'"
+            assert py_array == values, (
+                f"Wrong list of ints, expected '{values}' got '{py_array}'"
+            )
+            assert pd_array.shape == (1,), (
+                f"Wrong shape returned from pandas, expected '(1,)', got '{pd_array.shape}'"
+            )
+            assert type(pd_array[0]) == np.ndarray, (
+                f"Wrong type returned from pandas, expected 'numpy.ndarray' got '{type(pd_array[0])}'"
+            )
+            assert len(pd_array[0]) == 5, (
+                f"Wrong length of list returned from pandas, expected '5', got '{len(pd_array[0])}'"
+            )
+            assert np.all(pd_array[0] == values[0]), (
+                f"Wrong list of ints returned from pandas, expected '{values}' got '{pd_array[0]}'"
+            )
 
     def writeFsLocationViaPandas(self, data_sink, category, specifier, path):
         with kg.data_sink_mapper(data_sink) as sink:

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

@@ -367,7 +367,7 @@ def generate_versioned_schema_dict(extension_version):
                             "description": "An EnumSet Parameter\n\n**Available options:**\n\n- Foo: The "
                             "foo\n- Bar: The bar\n- Baz: The baz\n",
                             "items": {"type": "string"},
-                            "title": "EnumSet " "Parameter",
+                            "title": "EnumSet Parameter",
                             "type": "array",
                         },
                         "group": {
@@ -418,7 +418,7 @@ def generate_versioned_schema_dict(extension_version):
                             "description": "An EnumSet Parameter\n\n**Available options:**\n\n- Foo: The "
                             "foo\n- Bar: The bar\n- Baz: The baz\n",
                             "items": {"type": "string"},
-                            "title": "EnumSet " "Parameter",
+                            "title": "EnumSet Parameter",
                             "type": "array",
                         },
                         "group": {
@@ -1490,7 +1490,7 @@ def test_extract_schema(self):
                             "description": "An EnumSet Parameter\n\n**Available options:**\n\n- Foo: The "
                             "foo\n- Bar: The bar\n- Baz: The baz\n",
                             "items": {"type": "string"},
-                            "title": "EnumSet " "Parameter",
+                            "title": "EnumSet Parameter",
                             "type": "array",
                         },
                         "parameter_group": {

org.knime.python3.nodes/src/main/python/_node_backend_launcher.py

@@ -517,9 +517,9 @@ def deserialize_custom_spec() -> kn.PortObjectSpec:
         ):
             if port.type == kn.PortType.BINARY:
                 bpos = ks.BinaryPortObjectSpec.deserialize(data)
-                assert (
-                    bpos.id == port.id
-                ), f"Expected binary input port ID {port.id} but got {bpos.id}"
+                assert bpos.id == port.id, (
+                    f"Expected binary input port ID {port.id} but got {bpos.id}"
+                )
                 return bpos
             else:  # custom spec
                 return deserialize_custom_spec()
@@ -533,9 +533,9 @@ def deserialize_custom_spec() -> kn.PortObjectSpec:
         elif (
             class_name == "org.knime.core.node.workflow.capture.WorkflowPortObjectSpec"
         ):
-            assert (
-                port.type == kn.PortType.WORKFLOW
-            ), f"Expected a {port.type} but got a Workflow instead."
+            assert port.type == kn.PortType.WORKFLOW, (
+                f"Expected a {port.type} but got a Workflow instead."
+            )
             return ks.WorkflowPortObjectSpec.deserialize(data)
 
         raise TypeError("Unsupported PortObjectSpec found in Python, got " + class_name)
@@ -613,17 +613,17 @@ def spec_from_python(
             class_name = "org.knime.core.data.DataTableSpec"
         elif port.type == kn.PortType.BINARY:
             assert isinstance(spec, ks.BinaryPortObjectSpec)
-            assert (
-                port.id == spec.id
-            ), f"Expected binary output port ID {port.id} but got {spec.id}"
+            assert port.id == spec.id, (
+                f"Expected binary output port ID {port.id} but got {spec.id}"
+            )
 
             data = spec.serialize()
             class_name = "org.knime.python3.nodes.ports.PythonBinaryBlobPortObjectSpec"
         elif port.type == kn.PortType.IMAGE:
             assert isinstance(spec, ks.ImagePortObjectSpec)
-            assert any(
-                spec.format == option.value for option in kn.ImageFormat
-            ), f"Expected image formats are: {kn.ImageFormat.available_options()}."
+            assert any(spec.format == option.value for option in kn.ImageFormat), (
+                f"Expected image formats are: {kn.ImageFormat.available_options()}."
+            )
 
             data = spec.serialize()
             class_name = "org.knime.core.node.port.image.ImagePortObjectSpec"
@@ -632,12 +632,12 @@ def spec_from_python(
                 "WorkflowPortObjectSpecs can't be created in a Python node."
             )
         else:  # custom spec
-            assert (
-                port.type.id in self._port_types_by_id
-            ), f"Invalid output spec, no port type with id '{port.type.id}' registered. Please register the port type."
-            assert isinstance(
-                spec, port.type.spec_class
-            ), f"Expected output spec of type {port.type.spec_class} but got spec of type {type(spec)}"
+            assert port.type.id in self._port_types_by_id, (
+                f"Invalid output spec, no port type with id '{port.type.id}' registered. Please register the port type."
+            )
+            assert isinstance(spec, port.type.spec_class), (
+                f"Expected output spec of type {port.type.spec_class} but got spec of type {type(spec)}"
+            )
             data = {"id": port.type.id, "data": spec.serialize()}
 
             if issubclass(port.type.object_class, kn.ConnectionPortObject):
@@ -690,16 +690,16 @@ def read_port_object_data() -> Union[Any, kn.PortObject]:
             class_name
             == "org.knime.python3.nodes.ports.PythonTransientConnectionPortObject"
         ):
-            assert issubclass(
-                port.type.object_class, kn.ConnectionPortObject
-            ), f"unexpected port type {port.type}"
+            assert issubclass(port.type.object_class, kn.ConnectionPortObject), (
+                f"unexpected port type {port.type}"
+            )
             spec = self.spec_to_python(port_object.getSpec(), port, java_callback)
 
             data = json.loads(port_object.getSpec().toJsonString())
-            key = f'{data["node_id"]}:{data["port_idx"]}'
+            key = f"{data['node_id']}:{data['port_idx']}"
             if key not in _PortTypeRegistry._connection_port_data:
                 raise KeyError(
-                    f'No connection data found for node {data["node_id"]}, port {data["port_idx"]}. '
+                    f"No connection data found for node {data['node_id']}, port {data['port_idx']}. "
                     + "Please re-execute the upstream node providing the connection."
                 )
 
@@ -769,12 +769,12 @@ def port_object_from_python(
         elif port.type == kn.PortType.WORKFLOW:
             raise AssertionError("WorkflowPortObjects can't be created in Python.")
         else:
-            assert (
-                port.type.id in self._port_types_by_id
-            ), f"Invalid output port value, no port type with id '{id}' registered. Please register the port type."
-            assert isinstance(
-                obj, port.type.object_class
-            ), f"Expected output object of type {port.type.object_class}, got object of type {type(obj)}"
+            assert port.type.id in self._port_types_by_id, (
+                f"Invalid output port value, no port type with id '{id}' registered. Please register the port type."
+            )
+            assert isinstance(obj, port.type.object_class), (
+                f"Expected output object of type {port.type.object_class}, got object of type {type(obj)}"
+            )
             spec = self.spec_from_python(obj.spec, port, node_id, port_idx)
 
             if issubclass(port.type.object_class, kn.ConnectionPortObject):

org.knime.python3.nodes/src/main/python/knime/extension/parameter.py

@@ -2770,7 +2770,9 @@ def __get__(self, obj, obj_type=None):
 
                 Composed: return this instance.
                 """
-                assert self._is_descriptor(), "__get__ should only be called if the paramter_group is used as a descriptor."
+                assert self._is_descriptor(), (
+                    "__get__ should only be called if the paramter_group is used as a descriptor."
+                )
                 return self._get_param_holder(obj)
 
             def _get_value(self, obj, name, for_dialog: bool = False) -> Dict[str, Any]:

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

@@ -542,7 +542,7 @@ def test_to_str(self):
         sep = ",\n\t"
         self.assertEqual(
             str(s),
-            f"Schema<\n\t{sep.join(str(k.Column(t,n,None)) for t,n in zip(types, names))}>",
+            f"Schema<\n\t{sep.join(str(k.Column(t, n, None)) for t, n in zip(types, names))}>",
         )
 
     def test_logical_type_wrapping(self):

org.knime.python3/src/main/python/dataclasses_py36backport.py

@@ -366,7 +366,7 @@ def _tuple_str(obj_name, fields):
     if not fields:
         return "()"
     # Note the trailing comma, needed if this turns out to be a 1-tuple.
-    return f'({",".join([f"{obj_name}.{f.name}" for f in fields])},)'
+    return f"({','.join([f'{obj_name}.{f.name}' for f in fields])},)"
 
 
 def _create_fn(name, args, body, *, globals=None, locals=None, return_type=MISSING):
@@ -412,9 +412,7 @@ def _field_init(f, frozen, globals, self_name):
             # given, use it.  If not, call the factory.
             globals[default_name] = f.default_factory
             value = (
-                f"{default_name}() "
-                f"if {f.name} is _HAS_DEFAULT_FACTORY "
-                f"else {f.name}"
+                f"{default_name}() if {f.name} is _HAS_DEFAULT_FACTORY else {f.name}"
             )
         else:
             # This is a field that's not in the __init__ params, but
@@ -492,7 +490,7 @@ def _init_fn(fields, frozen, has_post_init, self_name):
                 seen_default = True
             elif seen_default:
                 raise TypeError(
-                    f"non-default argument {f.name!r} " "follows default argument"
+                    f"non-default argument {f.name!r} follows default argument"
                 )
 
     globals = {"MISSING": MISSING, "_HAS_DEFAULT_FACTORY": _HAS_DEFAULT_FACTORY}
@@ -729,7 +727,7 @@ def _get_field(cls, a_name, a_type):
     # Special restrictions for ClassVar and InitVar.
     if f._field_type in (_FIELD_CLASSVAR, _FIELD_INITVAR):
         if f.default_factory is not MISSING:
-            raise TypeError(f"field {f.name} cannot have a " "default factory")
+            raise TypeError(f"field {f.name} cannot have a default factory")
         # Should I check for other field settings? default_factory
         # seems the most serious to check for.  Maybe add others.  For
         # example, how about init=False (or really,
@@ -772,7 +770,7 @@ def _hash_add(cls, fields):
 
 def _hash_exception(cls, fields):
     # Raise an exception.
-    raise TypeError(f"Cannot overwrite attribute __hash__ " f"in class {cls.__name__}")
+    raise TypeError(f"Cannot overwrite attribute __hash__ in class {cls.__name__}")
 
 
 #
@@ -878,11 +876,11 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen):
     if has_dataclass_bases:
         # Raise an exception if any of our bases are frozen, but we're not.
         if any_frozen_base and not frozen:
-            raise TypeError("cannot inherit non-frozen dataclass from a " "frozen one")
+            raise TypeError("cannot inherit non-frozen dataclass from a frozen one")
 
         # Raise an exception if we're frozen, but none of our bases are.
         if not any_frozen_base and frozen:
-            raise TypeError("cannot inherit frozen dataclass from a " "non-frozen one")
+            raise TypeError("cannot inherit frozen dataclass from a non-frozen one")
 
     # Remember all of the fields on our class (including bases).  This
     # also marks this class as being a dataclass.
@@ -965,8 +963,7 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen):
         for fn in _frozen_get_del_attr(cls, field_list):
             if _set_new_attribute(cls, fn.__name__, fn):
                 raise TypeError(
-                    f"Cannot overwrite attribute {fn.__name__} "
-                    f"in class {cls.__name__}"
+                    f"Cannot overwrite attribute {fn.__name__} in class {cls.__name__}"
                 )
 
     # Decide if/how we're going to create a hash function.
@@ -1262,9 +1259,7 @@ class C:
 
         if f.name not in changes:
             if f._field_type is _FIELD_INITVAR:
-                raise ValueError(
-                    f"InitVar {f.name!r} " "must be specified with replace()"
-                )
+                raise ValueError(f"InitVar {f.name!r} must be specified with replace()")
             changes[f.name] = getattr(obj, f.name)
 
     # Create the new object, which calls __init__() and