Started integrating possibility for Python version check

Author: ThomasJejkal

build.gradle

@@ -8,6 +8,7 @@ plugins {
     id "com.gorylenko.gradle-git-properties" version "2.5.0"
     id 'io.freefair.lombok' version '8.13.1'
     id 'java'
+    id 'application'
     id 'jacoco'
 }
 
@@ -75,6 +76,7 @@ dependencies {
     implementation "org.javers:javers-spring-boot-starter-sql:${javersVersion}"
     implementation 'org.apache.httpcomponents:httpclient:4.5.14'
     implementation 'org.apache.commons:commons-collections4:4.4'
+    implementation 'org.apache.maven:maven-artifact:3.6.3'
     implementation 'org.json:json:20250107'
     implementation 'com.github.jknack:handlebars:4.4.0'
     implementation 'com.google.guava:guava:33.4.8-jre'

src/main/java/edu/kit/datamanager/mappingservice/configuration/ApplicationProperties.java

@@ -15,7 +15,6 @@
  */
 package edu.kit.datamanager.mappingservice.configuration;
 
-import edu.kit.datamanager.annotations.ExecutableFileURL;
 import edu.kit.datamanager.annotations.LocalFolderURL;
 import edu.kit.datamanager.validator.ExecutableFileValidator;
 import lombok.Data;

src/main/java/edu/kit/datamanager/mappingservice/util/PythonRunnerUtil.java

@@ -17,13 +17,15 @@
 import edu.kit.datamanager.mappingservice.configuration.ApplicationProperties;
 import edu.kit.datamanager.mappingservice.plugins.MappingPluginException;
 import edu.kit.datamanager.mappingservice.plugins.MappingPluginState;
+import java.io.ByteArrayOutputStream;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;
 
 import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.Collections;
+import org.apache.maven.artifact.versioning.ComparableVersion;
 
 /**
  * Utility class for running python scripts.
@@ -37,7 +39,6 @@ public class PythonRunnerUtil {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(PythonRunnerUtil.class);
 
-    
     public static void init(ApplicationProperties configuration) {
         PythonRunnerUtil.configuration = configuration;
     }
@@ -53,6 +54,85 @@ public static void printPythonVersion() {
         }
     }
 
+    
+    
+    
+    /**
+     * This method checks if the local Python installation version is larger or
+     * equal the provided version number. The version should be provided as
+     * semantic version number, i.e., 3.13.2
+     *
+     * The method will return TRUE if the minimal requirements are met and false
+     * otherwise. False is also returned if obtaining/parsing the local python
+     * version fails. for any reason.
+     * 
+     * @param versionString The semantic version string to compare the local Python version against.
+     * 
+     * @return True if versionString is smaller or equal the local Python version, false otherwise.
+     */
+    public static boolean hasMinimalPythonVersion(String versionString) {
+        boolean result = false;
+        try {
+            LOGGER.trace("Checking for minimal Python version {}.", versionString);
+            ByteArrayOutputStream bout = new ByteArrayOutputStream();
+            PythonRunnerUtil.runPythonScript("--version", bout, System.err);
+            LOGGER.trace("Version command output: {}", bout.toString());
+
+            String[] split = bout.toString().split(" ");
+
+            if (split.length == 2) {
+                String localPythonVersion = bout.toString().split(" ")[1].trim();
+                LOGGER.trace("Obtained local Python version: {}", localPythonVersion);
+                ComparableVersion localVersion = new ComparableVersion(localPythonVersion);
+                ComparableVersion minimalVersion = new ComparableVersion(versionString);
+                result = minimalVersion.compareTo(localVersion) <= 0;
+            } else {
+                LOGGER.info("Unexpected Python version output. Unable to check for minimal version.");
+            }
+        } catch (MappingPluginException e) {
+            LOGGER.error("Failed to obtain python version.", e);
+        }
+        return result;
+    }
+    
+     /**
+     * This method checks if the local Python installation version is larger or
+     * equal the provided version number. The version should be provided as
+     * semantic version number, i.e., 3.13.2
+     *
+     * The method will return TRUE if the minimal requirements are met and false
+     * otherwise. False is also returned if obtaining/parsing the local python
+     * version fails. for any reason.
+     * 
+     * @param versionString The semantic version string to compare the local Python version against.
+     * 
+     * @return True if versionString is smaller or equal the local Python version, false otherwise.
+     */
+    public static boolean hasMaximalPythonVersion(String versionString) {
+        boolean result = false;
+        try {
+            LOGGER.trace("Checking for minimal Python version {}.", versionString);
+            ByteArrayOutputStream bout = new ByteArrayOutputStream();
+            PythonRunnerUtil.runPythonScript("--version", bout, System.err);
+            LOGGER.trace("Version command output: {}", bout.toString());
+
+            String[] split = bout.toString().split(" ");
+
+            if (split.length == 2) {
+                String localPythonVersion = bout.toString().split(" ")[1].trim();
+                LOGGER.trace("Obtained local Python version: {}", localPythonVersion);
+                ComparableVersion localVersion = new ComparableVersion(localPythonVersion);
+                ComparableVersion minimalVersion = new ComparableVersion(versionString);
+                result = minimalVersion.compareTo(localVersion) > 0;
+            } else {
+                LOGGER.info("Unexpected Python version output. Unable to check for minimal version.");
+            }
+        } catch (MappingPluginException e) {
+            LOGGER.error("Failed to obtain python version.", e);
+        }
+        return result;
+    }
+
     /**
      * This method executes an argument/option on the python interpreter.
      *
@@ -102,4 +182,25 @@ public static MappingPluginState runPythonScript(String script, OutputStream out
         }
         return ShellRunnerUtil.run(output, error, command.toArray(String[]::new));
     }
+
+    public static void main(String[] args) throws Exception {
+        ArrayList<String> command = new ArrayList<>();
+        command.add("/opt/homebrew/bin/python3");
+        command.add("--version");
+        if (args != null) {
+            Collections.addAll(command, args);
+        }
+
+        ByteArrayOutputStream bout = new ByteArrayOutputStream();
+
+        ShellRunnerUtil.run(bout, System.err, command.toArray(String[]::new));
+        System.out.println("VERS " + bout.toString());
+        System.out.println(bout.toString().split(" ")[1]);
+        ComparableVersion verr = new ComparableVersion("unknown");
+        System.out.println("ER " + verr.getCanonical());
+        ComparableVersion v = new ComparableVersion(bout.toString().split(" ")[1].trim());
+        ComparableVersion vMin = new ComparableVersion("4");
+        System.out.println(verr.compareTo(v));
+
+    }
 }