first vesion of parameters.py

emzed/ext/mzmine2/__init__.py

-import os
+import os as _os
 
-from .install_jre import install_jre  # noqa: F401
-from .install_mzmine2 import install_mzmine2  # noqa: F401
+from .install_jre import get_jre_home
+from .install_mzmine2 import get_mzmine2_home
 
-HERE = os.path.dirname(os.path.abspath(__file__))
+if get_mzmine2_home() is None or get_jre_home() is None:
 
-_jvm_started = False
+    def init():
+        from .install_jre import install_jre
+        from .install_mzmine2 import install_mzmine2
 
+        install_jre()
+        install_mzmine2()
 
-def _start_jvm_if_not_done_yet():
-    global _jvm_started
+        print()
+        print(f"please close this session and import {__package__} again")
 
-    if not _jvm_started:
-        import jpype
-        from .install_mzmine2 import mzmine2_home_folder
-        from .install_jre import set_java_home
 
-        set_java_home()
+    # cleanup ns
+    del get_jre_home
+    del get_mzmine2_home
 
-        jpype.startJVM(
-            jpype.getDefaultJVMPath(),
-            "-Djava.awt.headless=true",
-            classpath=[
-                mzmine2_home_folder() + "/lib/*",
-                os.path.join(HERE, "java", "extensions.jar"),
-            ],
-            convertStrings=True,
-        )
-        _jvm_started = True
+    print(f"please call {__package__}.init() first")
+
+
+else:
+
+    _jvm_started = False
+    HERE = _os.path.dirname(_os.path.abspath(__file__))
+
+    def _start_jvm_if_not_done_yet():
+        global _jvm_started
+
+        if not _jvm_started:
+            from .install_mzmine2 import get_mzmine2_home
+            from .install_jre import set_java_home
+            import jpype
+
+            set_java_home()
+
+            jpype.startJVM(
+                jpype.getDefaultJVMPath(),
+                "-Djava.awt.headless=true",
+                classpath=[
+                    get_mzmine2_home() + "/lib/*",
+                    _os.path.join(HERE, "java", "extensions.jar"),
+                ],
+                convertStrings=True,
+            )
+            _jvm_started = True
+
+    from . import io, converters

emzed/ext/mzmine2/classes.py

@@ -4,26 +4,36 @@
 import jpype
 
 
-def MzMineClass(path):
+def MzMine2Class(path):
     return jpype.JClass("net.sf.mzmine." + path)
 
 
-
-Project = MzMineClass("project.impl.MZmineProjectImpl")
-RawDataFileImpl = MzMineClass("project.impl.RawDataFileImpl")
+Project = MzMine2Class("project.impl.MZmineProjectImpl")
+RawDataFileImpl = MzMine2Class("project.impl.RawDataFileImpl")
 File = jpype.JClass("java.io.File")
 
-MzXMLReadTask = MzMineClass("modules.rawdatamethods.rawdataimport.fileformats.MzXMLReadTask")
+MzXMLReadTask = MzMine2Class(
+    "modules.rawdatamethods.rawdataimport.fileformats.MzXMLReadTask"
+)
 
 
-StorableScan = MzMineClass("project.impl.StorableScan")
-SimpleScan = MzMineClass("datamodel.impl.SimpleScan")
-SimpleDataPoint = MzMineClass("datamodel.impl.SimpleDataPoint")
-MassSpectrumType = MzMineClass("datamodel.MassSpectrumType")
-PolarityType = MzMineClass("datamodel.PolarityType")
+StorableScan = MzMine2Class("project.impl.StorableScan")
+SimpleScan = MzMine2Class("datamodel.impl.SimpleScan")
+SimpleDataPoint = MzMine2Class("datamodel.impl.SimpleDataPoint")
+MassSpectrumType = MzMine2Class("datamodel.MassSpectrumType")
+PolarityType = MzMine2Class("datamodel.PolarityType")
 
-RawDataExportTask = MzMineClass("modules.rawdatamethods.rawdataexport.RawDataExportTask")
+RawDataExportTask = MzMine2Class(
+    "modules.rawdatamethods.rawdataexport.RawDataExportTask"
+)
 
 DataPointArrayHelpers = jpype.JClass("ch.ethz.emzed.DataPointArrayHelpers")
 
 DoubleRange = jpype.JClass("ch.ethz.emzed.DoubleRange")
+
+ParameterSet = MzMine2Class("parameters.ParameterSet")
+Parameter = MzMine2Class("parameters.Parameter")
+
+ShoulderPeaksFilterParameters = MzMine2Class(
+    "modules.masslistmethods.shoulderpeaksfilter.ShoulderPeaksFilterParameters"
+)

emzed/ext/mzmine2/install_jre.py

@@ -52,13 +52,20 @@ def install_jre(platform=sys.platform, target_folder=_default_jre_folder()):
         fh.write(unpacked_to)
 
 
-def set_java_home(folder=_default_jre_folder()):
+def get_jre_home(folder=_default_jre_folder()):
     jvm_home_path = os.path.join(folder, JVM_HOME_FILE)
     if not os.path.exists(jvm_home_path):
-        raise RuntimeError(f"did not find {jvm_home_path}, did you run download_jre()?")
+        return None
 
     path = open(jvm_home_path).read().strip()
     if not os.path.exists(path):
         raise RuntimeError(f"file {jvm_home_path} contains invalid path {path}")
 
+    return path
+
+
+def set_java_home(folder=_default_jre_folder()):
+    path = get_jre_home(folder)
+    if path is None:
+        raise RuntimeError(f"did not find {jvm_home_path}, did you run download_jre()?")
     os.environ["JAVA_HOME"] = path

emzed/ext/mzmine2/install_mzmine2.py

@@ -35,5 +35,14 @@ def install_mzmine2(target_folder=_default_mzmine2_folder()):
         fh.write(result_folder)
 
 
-def mzmine2_home_folder(target_folder=_default_mzmine2_folder()):
-    return open(os.path.join(target_folder, MZMINE2_HOME_FILE)).read()
+def get_mzmine2_home(target_folder=_default_mzmine2_folder()):
+    mzmine2_path = os.path.join(target_folder, MZMINE2_HOME_FILE)
+
+    if not os.path.exists(mzmine2_path):
+        return None
+
+    path = open(mzmine2_path).read().strip()
+    if not os.path.exists(path):
+        raise RuntimeError(f"file {mzmine2_path} contains invalid path {path}")
+
+    return path

emzed/ext/mzmine2/io.py

 #! /usr/bin/env python
 # Copyright © 2019 Uwe Schitt <uwe.schmitt@id.ethz.ch>
 
+
 import os
 
 import jpype
 
-from . import _start_jvm_if_not_done_yet
-
 
 def read_mzxml(path):
-    if not os.path.exists(path):
-        raise IOError(f"file {path} does not exist")
+
+    from emzed.ext.mzmine2 import _start_jvm_if_not_done_yet
 
     _start_jvm_if_not_done_yet()
 
-    # delayed import because we don't know if mzmine2 is available yet:
     from .classes import (
         DataPointArrayHelpers,
         DoubleRange,
@@ -29,6 +27,9 @@ def read_mzxml(path):
         SimpleScan,
     )
 
+    if not os.path.exists(path):
+        raise IOError(f"file {path} does not exist")
+
     writer = RawDataFileImpl(None)
 
     mzxml_file = File(path)

emzed/ext/mzmine2/parameters.py

+import re
+from dataclasses import make_dataclass
+from textwrap import dedent
+
+from . import _start_jvm_if_not_done_yet
+
+
+def descriptor_class(class_name, python_type):
+    dd = {}
+    exec(
+        f"""class {class_name}:
+
+        def __init__(self, name):
+            self._value = None
+            self._name = name
+
+        def __set__(self, instance, value):
+            assert isinstance(value, {python_type}),\
+                   "expect value of type {python_type} for field %s" % self._name
+            self._value = value
+
+        def __get__(self, instance, owner):
+            assert self._value is not None, \
+                   "value for '%s' was not set yet" % self._name
+            return self._value
+            """,
+        None,
+        dd,
+    )
+
+    return dd[class_name]
+
+
+def combo_descriptor_class(class_name, choices):
+    dd = {}
+    exec(
+        f"""class {class_name}:
+
+        def __init__(self, name):
+            self._value = None
+            self._name = name
+
+        def __set__(self, instance, value):
+            assert value in {choices}, \
+                   "expected values are {choices} for field %s" % self._name
+            self._value = value
+
+        def __get__(self, instance, owner):
+            assert self._value is not None,  \
+                   ("value for '%s' was not set yet, "
+                    "allowed values are {choices}" % (self._name,))
+            return self._value
+            """,
+        None,
+        dd,
+    )
+
+    return dd[class_name]
+
+
+BooleanParameterPython = lambda c: descriptor_class("BooleanParameterPython", "bool")
+DoubleParameterPython = lambda c: descriptor_class("DoubleParameterPython", "float")
+StringParameterPython = lambda c: descriptor_class("StringParameterPython", "str")
+
+
+def _to_camel_case(txt):
+    return txt.title().replace(" ", "")
+
+
+def _from_camel_case(txt):
+    # from https://stackoverflow.com/questions/1175208
+    txt = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", txt)
+    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", txt).lower()
+
+
+def construct_combo_type(java_type):
+    values = [c.name() for c in java_type.getChoices()]
+    name = _to_camel_case(java_type.getName())
+    return combo_descriptor_class(name, values)
+
+
+def _mzmine2_to_from_python_types_mapping():
+
+    _start_jvm_if_not_done_yet()
+    from .classes import MzMine2Class
+
+    BooleanParameterJava = MzMine2Class("parameters.parametertypes.BooleanParameter")
+    ComboParameter = MzMine2Class("parameters.parametertypes.ComboParameter")
+    DoubleParameterJava = MzMine2Class("parameters.parametertypes.DoubleParameter")
+    StringParameterJava = MzMine2Class("parameters.parametertypes.StringParameter")
+
+    mzmine2_to_python = {
+        BooleanParameterJava: BooleanParameterPython,
+        DoubleParameterJava: DoubleParameterPython,
+        StringParameterJava: StringParameterPython,
+        ComboParameter: construct_combo_type,
+    }
+
+    python_to_mzmine2 = dict((v, k) for (k, v) in mzmine2_to_python.items())
+
+    return mzmine2_to_python, python_to_mzmine2
+
+
+def to_python_class(parameter_set, only_fields=None):
+
+    from .classes import Parameter, ParameterSet
+
+    assert isinstance(parameter_set, ParameterSet)
+
+    mzmine2_to_python, __ = _mzmine2_to_from_python_types_mapping()
+
+    fields = []
+    doc_lines = []
+    for field_name in parameter_set.__dir__():
+        p = getattr(parameter_set, field_name, None)
+        if not isinstance(p, Parameter):
+            continue
+
+        python_name = _from_camel_case(field_name)
+        if only_fields is not None and python_name not in only_fields:
+            continue
+
+        python_type_factory = mzmine2_to_python.get(p.__class__)
+        if python_type_factory is None:
+            continue
+        desc = p.getDescription()
+        python_name = _from_camel_case(field_name)
+
+        doc_lines.append(f"{python_name}: {desc}")
+        fields.append((python_name, field_name, python_type_factory(p)))
+
+    attributes = {name: python_type(name) for (name, __, python_type) in fields}
+    attributes["__doc__"] = "\n\n".join(doc_lines)
+
+    attributes["_fields"] = [
+        (python_name, field_name) for (python_name, field_name, __) in fields
+    ]
+
+    attributes["_java_class"] = parameter_set.__class__.__name__
+    clz = type(parameter_set.__name__.rsplit(".", 1)[1], (), attributes)
+
+    return clz
+
+
+def from_python_obj(obj):
+
+    assert hasattr(obj, "_fields"), "this is not a proper parameter class"
+    assert hasattr(obj, "_java_class"), "this is not a proper parameter class"
+
+    from jpype import JClass
+
+    java_obj = JClass(obj._java_class)()
+    for name_python, name_java in obj._fields:
+        getattr(java_obj, name_java).setValue(getattr(obj, name_python))
+    return java_obj

tests/conftest.py

@@ -39,3 +39,4 @@ def data_path():
 
 from emzed.ext.mzmine2.install_jre import set_java_home
 set_java_home()
+

tests/test_install.py

@@ -6,9 +6,8 @@ import sys
 
 import pytest
 
-from emzed.ext.mzmine2 import install_jre, install_mzmine2
-from emzed.ext.mzmine2.install_jre import set_java_home
-from emzed.ext.mzmine2.install_mzmine2 import mzmine2_home_folder
+from emzed.ext.mzmine2.install_jre import install_jre, set_java_home
+from emzed.ext.mzmine2.install_mzmine2 import get_mzmine2_home, install_mzmine2
 
 is_ci_server = os.environ.get("CI") is not None
 
@@ -30,7 +29,7 @@ def test_install_jre(platform, tmpdir, regtest):
 def test_install_mzmine2(tmpdir, regtest):
     mzmine2_folder = tmpdir.strpath
     install_mzmine2(mzmine2_folder)
-    print(mzmine2_home_folder(mzmine2_folder), file=regtest)
+    print(get_mzmine2_home(mzmine2_folder), file=regtest)
 
 
 @pytest.mark.skipif(is_ci_server, reason="only runs locally")
@@ -44,4 +43,4 @@ def test_install_jre_local():
 @pytest.mark.skipif(is_ci_server, reason="only runs locally")
 def test_install_mzmine2_local():
     install_mzmine2()
-    assert "lib" in os.listdir(mzmine2_home_folder())
+    assert "lib" in os.listdir(get_mzmine2_home())

tests/test_io.py

 #! /usr/bin/env python
 # Copyright © 2019 Uwe Schitt <uwe.schmitt@id.ethz.ch>
 
+
 from emzed.ext.mzmine2.io import read_mzxml
 
 

tests/test_parameter_handling.py

+#! /usr/bin/env python
+# Copyright © 2019 Uwe Schitt <uwe.schmitt@id.ethz.ch>
+
+# from emzed.ext.mzmine2.classes import MzMine2Class
+
+
+def test_param_conversion():
+    from emzed.ext.mzmine2 import _start_jvm_if_not_done_yet
+    from jpype import JClass
+
+    _start_jvm_if_not_done_yet()
+    from emzed.ext.mzmine2.parameters import to_python_class, from_python_obj
+    from emzed.ext.mzmine2.classes import ShoulderPeaksFilterParameters
+
+    py_class = to_python_class(
+        ShoulderPeaksFilterParameters(),
+        only_fields=["resolution", "auto_remove", "peak_model"],
+    )
+
+    py_obj = py_class()
+    py_obj.resolution = 123.0
+    py_obj.auto_remove = True
+    py_obj.peak_model = "GAUSS"
+    java_obj = from_python_obj(py_obj)
+
+    assert java_obj.resolution.getValue() == 123.0
+    assert java_obj.autoRemove.getValue() == True
+    assert java_obj.peakModel.getValue() == "GAUSS"