feat: requirements.txt support for maven plugin

graalpy-maven-plugin/src/main/java/org/graalvm/python/maven/plugin/AbstractGraalPyMojo.java

@@ -40,6 +40,7 @@
  */
 package org.graalvm.python.maven.plugin;
 
+import java.util.ArrayList;
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.artifact.DefaultArtifact;
 import org.apache.maven.artifact.handler.DefaultArtifactHandler;
@@ -110,6 +111,9 @@ public AbstractGraalPyMojo(ProjectBuilder projectBuilder) {
 	@Parameter
 	List<String> packages;
 
+    @Parameter(property = "requirementsFile")
+    String requirementsFile;
+
 	@SuppressFBWarnings("UUF_UNUSED_FIELD")
 	public static class PythonHome {
 		@SuppressWarnings("unused")
@@ -124,7 +128,7 @@ public static class PythonHome {
 	@Parameter(defaultValue = "${session}", readonly = true, required = true)
 	private MavenSession session;
 
-	private ProjectBuilder projectBuilder;
+    private final ProjectBuilder projectBuilder;
 
 	private Set<String> launcherClassPath;
 
@@ -148,14 +152,25 @@ protected void listGraalPyResources() throws MojoExecutionException {
 		}
 	}
 
-	protected void preExec(boolean enableWarnings) throws MojoExecutionException {
-		pythonResourcesDirectory = normalizeEmpty(pythonResourcesDirectory);
-		externalDirectory = normalizeEmpty(externalDirectory);
-		resourceDirectory = normalizeEmpty(resourceDirectory);
-		graalPyLockFile = normalizeEmpty(graalPyLockFile);
-		packages = packages != null
-				? packages.stream().filter(p -> p != null && !p.trim().isEmpty()).toList()
-				: List.of();
+    protected void preExec(boolean enableWarnings) throws MojoExecutionException {
+        pythonResourcesDirectory = normalizeEmpty(pythonResourcesDirectory);
+        externalDirectory = normalizeEmpty(externalDirectory);
+        resourceDirectory = normalizeEmpty(resourceDirectory);
+        graalPyLockFile = normalizeEmpty(graalPyLockFile);
+        Path reqFilePath = resolveReqFile();
+        if (reqFilePath != null) {
+            getLog().info("GraalPy requirements file: " + reqFilePath);
+            if (packages != null) {
+                throw new MojoExecutionException(
+                        "Cannot use <packages> and <requirementsFile> at the same time. "
+                                + "New option <requirementsFile> is a replacement for using <packages> with list of inline <package>.");
+            }
+            packages = new ArrayList<>();
+        } else if (packages != null) {
+            packages = packages.stream()
+                    .filter(p -> p != null && !p.trim().isEmpty())
+                    .toList();
+        }
 
 		if (pythonResourcesDirectory != null) {
 			if (externalDirectory != null) {
@@ -201,7 +216,29 @@ protected void preExec(boolean enableWarnings) throws MojoExecutionException {
 		}
 	}
 
-	protected void postExec() throws MojoExecutionException {
+    protected Path resolveReqFile() {
+        if (requirementsFile == null || requirementsFile.isBlank()) {
+            return null;
+        }
+
+        Path path = Path.of(requirementsFile);
+        Path finalPath = path.isAbsolute()
+                ? path
+                : project.getBasedir().toPath().resolve(path).normalize();
+
+        if (Files.exists(finalPath)) {
+            return finalPath;
+        }
+
+        Path defaultReq = project.getBasedir().toPath().resolve("requirements.txt").normalize();
+        if (Files.exists(defaultReq)) {
+            return defaultReq;
+        }
+
+        return null;
+    }
+
+    protected void postExec() throws MojoExecutionException {
 		for (Resource r : project.getBuild().getResources()) {
 			if (Files.exists(Path.of(r.getDirectory(), resourceDirectory, "proj"))) {
 				getLog().warn(String.format("usage of %s is deprecated, use %s instead",
@@ -249,12 +286,11 @@ private static String normalizeEmpty(String s) {
 	}
 
 	protected Launcher createLauncher() {
-		Launcher launcherArg = new Launcher(getLauncherPath()) {
-			public Set<String> computeClassPath() throws IOException {
-				return calculateLauncherClasspath(project);
-			}
-		};
-		return launcherArg;
+        return new Launcher(getLauncherPath()) {
+            public Set<String> computeClassPath() throws IOException {
+                return calculateLauncherClasspath(project);
+            }
+        };
 	}
 
 	protected Path getLockFile() {
@@ -293,7 +329,7 @@ protected static String getGraalPyVersion(MavenProject project) throws IOExcepti
 
 	private static Artifact getGraalPyArtifact(MavenProject project) throws IOException {
 		var projectArtifacts = resolveProjectDependencies(project);
-		Artifact graalPyArtifact = projectArtifacts.stream().filter(a -> isPythonArtifact(a)).findFirst().orElse(null);
+		Artifact graalPyArtifact = projectArtifacts.stream().filter(AbstractGraalPyMojo::isPythonArtifact).findFirst().orElse(null);
 		return Optional.ofNullable(graalPyArtifact).orElseThrow(() -> new IOException(
 				"Missing GraalPy dependency. Please add to your pom either %s:%s or %s:%s".formatted(POLYGLOT_GROUP_ID,
 						PYTHON_COMMUNITY_ARTIFACT_ID, POLYGLOT_GROUP_ID, PYTHON_ARTIFACT_ID)));
@@ -326,6 +362,7 @@ private Set<String> calculateLauncherClasspath(MavenProject project) throws IOEx
 							&& PYTHON_LAUNCHER_ARTIFACT_ID.equals(a.getArtifactId()))
 					.findFirst().orElse(null);
 			// python-launcher artifact
+            assert graalPyLauncherArtifact != null;
 			launcherClassPath.add(graalPyLauncherArtifact.getFile().getAbsolutePath());
 			// and transitively all its dependencies
 			launcherClassPath.addAll(resolveDependencies(graalPyLauncherArtifact));

graalpy-maven-plugin/src/main/java/org/graalvm/python/maven/plugin/InstallPackagesMojo.java

@@ -46,6 +46,7 @@
 import org.apache.maven.plugins.annotations.ResolutionScope;
 import org.apache.maven.project.ProjectBuilder;
 import org.graalvm.python.embedding.tools.vfs.VFSUtils;
+import org.graalvm.python.embedding.tools.vfs.VFSUtils.Launcher;
 import org.graalvm.python.embedding.tools.vfs.VFSUtils.PackagesChangedException;
 
 import javax.inject.Inject;
@@ -98,9 +99,10 @@ private void manageVenv() throws MojoExecutionException {
 		Path venvDirectory = getVenvDirectory();
 		MavenDelegateLog log = new MavenDelegateLog(getLog());
 		Path lockFile = getLockFile();
+        Path reqFile = resolveReqFile();
 		try {
 			VFSUtils.createVenv(venvDirectory, packages, lockFile, MISSING_LOCK_FILE_WARNING, createLauncher(),
-					getGraalPyVersion(project), log);
+					getGraalPyVersion(project), log, reqFile);
 		} catch (PackagesChangedException pce) {
 			String pluginPkgsString = pce.getPluginPackages().isEmpty()
 					? "None"

graalpy-maven-plugin/src/main/java/org/graalvm/python/maven/plugin/LockPackagesMojo.java

@@ -64,8 +64,50 @@ public class LockPackagesMojo extends AbstractGraalPyMojo {
 			This file contains a list of all required Python packages with their specific versions,
 			based on the packages defined in the plugin configuration and their dependencies.
 			""";
-
-	@Inject
+    public static final String MISSING_DEPENDENCY_CONFIGURATION_ERROR = """
+            In order to run the lock-packages goal you must declare Python dependencies in the graalpy-maven-plugin configuration.
+
+            You must configure Python dependencies in one of the following ways:
+
+              Option 1: Use <packages> with inline versioned package entries:
+
+                <plugin>
+                  <groupId>org.graalvm.python</groupId>
+                  <artifactId>graalpy-maven-plugin</artifactId>
+                  <configuration>
+                    <packages>
+                      <package>{package_name}=={package_version}</package>
+                    </packages>
+                    ...
+                  </configuration>
+                </plugin>
+
+              Option 2: Use a pip-compatible requirements.txt file:
+
+                <plugin>
+                  <groupId>org.graalvm.python</groupId>
+                  <artifactId>graalpy-maven-plugin</artifactId>
+                  <configuration>
+                    <requirementsFile>requirements.txt</requirementsFile>
+                    ...
+                  </configuration>
+                </plugin>
+
+            IMPORTANT:
+              • The requirementsFile workflow follows pip's native behavior.
+              • GraalPy lock files are NOT used or generated when requirementsFile is specified.
+              • The 'lock-packages' goal is NOT supported with <requirementsFile>.
+              • Users are expected to manage locking / freezing themselves using pip conventions (e.g., pip freeze).
+              • Do not define both <packages> and <requirementsFile> at the same time.
+              • The <configuration> section must be declared on the graalpy-maven-plugin itself,
+                not inside a specific execution.
+
+            For more details, see:
+            https://github.com/oracle/graalpython/blob/master/docs/user/Embedding-Build-Tools.md
+            """;
+
+
+    @Inject
 	public LockPackagesMojo(ProjectBuilder projectBuilder) {
 		super(projectBuilder);
 	}
@@ -93,33 +135,15 @@ protected void manageVenv() throws MojoExecutionException {
 		}
 	}
 
-	private void checkEmptyPackages() throws MojoExecutionException {
-		if ((packages == null || packages.isEmpty())) {
-			getLog().error("");
-			getLog().error(
-					"In order to run the lock-packages goal there have to be python packages declared in the graalpy-maven-plugin configuration.");
-			getLog().error("");
-			getLog().error(
-					"NOTE that the <configuration> section has to be declared for the whole graalpy-maven-plugin");
-			getLog().error("and not specifically for the process-graalpy-resources execution goal.");
-			getLog().error("");
-			getLog().error("Please add the <packages> section to your configuration as follows:");
-			getLog().error("<plugin>");
-			getLog().error("  <groupId>org.graalvm.python</groupId>");
-			getLog().error("  <artifactId>graalpy-maven-plugin</artifactId>");
-			getLog().error("  <configuration>");
-			getLog().error("    <packages>");
-			getLog().error("      <package>{package_name}=={package_version}</package>");
-			getLog().error("    </packages>");
-			getLog().error("    ...");
-			getLog().error("  </configuration>");
-			getLog().error("");
-
-			getLog().error(
-					"For more information, please refer to https://github.com/oracle/graalpython/blob/master/docs/user/Embedding-Build-Tools.md");
-			getLog().error("");
-
-			throw new MojoExecutionException("missing python packages in plugin configuration");
-		}
-	}
+    private void checkEmptyPackages() throws MojoExecutionException {
+        Path reqFilePath = resolveReqFile();
+        boolean emptyPackages = packages == null || packages.isEmpty();
+        boolean requirementsExists = reqFilePath != null;
+        if (emptyPackages && !requirementsExists) {
+            getLog().error("");
+            getLog().error(MISSING_DEPENDENCY_CONFIGURATION_ERROR);
+            getLog().error("");
+            throw new MojoExecutionException("Missing Python dependency configuration.");
+        }
+    }
 }

integration-tests/prepare_venv_requirements_pom.xml

@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+Copyright (c) 2023, 2023, Oracle and/or its affiliates. All rights reserved.
+DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+
+The Universal Permissive License (UPL), Version 1.0
+
+Subject to the condition set forth below, permission is hereby granted to any
+person obtaining a copy of this software, associated documentation and/or
+data (collectively the "Software"), free of charge and under any and all
+copyright rights in the Software, and any and all patent rights owned or
+freely licensable by each licensor hereunder covering either (i) the
+unmodified Software as contributed to or provided by such licensor, or (ii)
+the Larger Works (as defined below), to deal in both
+
+(a) the Software, and
+
+(b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+one is included with the Software each a "Larger Work" to which the Software
+is contributed by such licensors),
+
+without restriction, including without limitation the rights to copy, create
+derivative works of, display, perform, and distribute the Software and make,
+use, sell, offer for sale, import, export, have made, and have sold the
+Software and the Larger Work(s), and to sublicense the foregoing rights on
+either these or other terms.
+
+This license is subject to the following condition:
+
+The above copyright notice and either this complete permission notice or at a
+minimum a reference to the UPL must be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>org.apache.maven.plugin.my.unit</groupId>
+  <artifactId>project-prepare-venv</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+  <name>Test MyMojo</name>
+
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>3.8.1</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.graalvm.polyglot</groupId>
+      <artifactId>python</artifactId>
+      <version>${env.GRAALPY_VERSION}</version>
+      <type>pom</type>
+    </dependency>
+    <dependency>
+      <groupId>org.graalvm.python</groupId>
+      <artifactId>python-launcher</artifactId>
+      <version>${env.GRAALPY_VERSION}</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.graalvm.python</groupId>
+        <artifactId>graalpy-maven-plugin</artifactId>
+        <version>${env.GRAALPY_VERSION}</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>process-graalpy-resources</goal>
+            </goals>
+          </execution>
+        </executions>
+          <configuration>
+              <requirementsFile>requirements.txt</requirementsFile>
+          </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>

integration-tests/test_maven_plugin.py

@@ -835,6 +835,32 @@ def test_multiple_namespaced_vfs(self):
             assert return_code == 0, log
 
 
+    def test_requirements_txt_packages(self):
+      with util.TemporaryTestDirectory() as dir:
+        target_name = "requirements_packages"
+        target_dir = os.path.join(str(dir), target_name)
+        pom_template = os.path.join(
+            os.path.dirname(__file__),
+            "prepare_venv_requirements_pom.xml",
+        )
+        self.generate_app(dir, target_dir, target_name, pom_template)
+
+        requirements_txt = os.path.join(target_dir, "requirements.txt")
+        if not os.path.exists(requirements_txt):
+          with open(requirements_txt, "w", encoding="utf-8") as f:
+            f.write("pyfiglet==1.0.2\n")
+
+        mvnw_cmd = util.get_mvn_wrapper(target_dir, self.env)
+
+        cmd = mvnw_cmd + ["process-resources"]
+        out, return_code = util.run_cmd(cmd, self.env, cwd=target_dir)
+        util.check_ouput("BUILD SUCCESS", out)
+        assert return_code == 0
+
+        lock_file = os.path.join(target_dir, "graalpy.lock")
+        assert not os.path.exists(lock_file)
+
+
 if __name__ == "__main__":
     run_path = os.path.join(os.path.abspath(__file__), 'run.py')
     print(f"Run this file using the run.py driver ({run_path})")