source: java2python/src/main/java/tudelft/utilities/j2p/PyProgram.java@ 399

package tudelft.utilities.j2p;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import tudelft.utilities.pyrunner.Call;
import tudelft.utilities.pyrunner.PythonError;
import tudelft.utilities.pyrunner.PythonVenv;

/**
 * Contains a fully runnable python program. This contains multiple
 * {@link PyModule}s.
 *
 */
public class PyProgram {
        private final List<PyModule> modules;

        public PyProgram(List<PyModule> modules) {
                this.modules = modules;
        }

        /**
         * 
         * /**
         * 
         * @param javaBaseDir the java base dir from where packages are found,
         *                    typically src/main/java.
         * @param modulenames list of full.qualified.path.java list of java programs
         *                    inside the base dir. Each java source file of the
         *                    program is relative to the javaBaseDir. This
         *                    relativeness allows us to derive the correct filename,
         *                    class path etc, without requesting an actual class
         *                    object.
         * @return PyProgram containing the translated java program including all
         *         specified packages
         * @throws FileNotFoundException if file can't be found
         */

        public static PyProgram fromModules(Path javaBaseDir, List<File> modules)
                        throws FileNotFoundException {
                List<PyModule> pymodules = new LinkedList<>();

                for (File module : modules) {
                        pymodules.add(PyModule.fromJavaFile(javaBaseDir, module));
                }
                return new PyProgram(pymodules);

        }

        /**
         * 
         * @param pycode     the python code to be zipped as pip-installable zip. It
         *                   is assumed that the code is just 1 file.
         * @param modulename The name of the module. It is assumed there is just 1
         *                   module, and this module is also a directory in the root
         *                   folder, and only 1 level deep. The main program must be
         *                   in this module. FIXME should be in pycode.
         * @return a zip {@link File} containing all the code, as a python tar.gz
         *         package that can be pip install'ed . For instance like this:
         *         
         *         <pre><!-- @formatter:off -->
         *      PythonVenv venv = new PythonVenv(zipfile, reporter);
         *      String res = venv.call(Arrays.asList("-m", "testcode"), 10000);
                                </pre><!-- @formatter:on -->
         * @throws IOException
         * @throws PythonError          if python code to build tar.gz fails for
         *                              some reason
         * @throws InterruptedException
         */
        public File getZip() throws IOException, InterruptedException, PythonError {
                // HACK we need to find good name and properly enumerate ALL modules,
                // not just first one.
                String modulename = modules.get(0).getSourceFile().toString()
                                .split("/")[0];

                Path tmppath = Files.createTempDirectory("j2p");
                System.out.println(tmppath);

                Set<String> installs = new HashSet<String>();
                List<String> modulenames = new LinkedList<>();
                // write the translated file
                for (PyModule pymodule : modules) {
                        String modname = pymodule.getSourceFile().getPath().replace(".java",
                                        "");
                        modulenames.add("'" + modname + "'");
                        File f = tmppath.resolve(modname + ".py").toFile();
                        f.getParentFile().mkdirs();// create dirs
                        FileOutputStream fos = new FileOutputStream(f);
                        BufferedOutputStream bos = new BufferedOutputStream(fos);
                        // convert string to byte array
                        String filter = "from " + modname.replace("/", ".") + " .*";
                        byte[] bytes = pymodule.getCode().toCode(filter).getBytes();
                        // write byte array to file
                        bos.write(bytes);
                        bos.close();
                        fos.close();
                        installs.addAll(pymodule.getCode().getInstalls());
                }

                List<String> requirements = installs.stream()
                                .map(str -> "\"" + str + "\"").toList();
                // we must provide many nonsense fields like url and author to get this
                // working...
                String setuppy = "from setuptools import setup, find_packages\n" + "\n"
                                + "setup(\n" + "    name='" + modulename + "',\n"
                                + "    version=1,\n" + "    author='Whatever',\n"
                                + "    author_email='Whatever',\n"
                                + "    url='http://nonsense',\n" + "    py_modules="
                                + modulenames + ",\n" + "    install_requires=" + requirements
                                + ",\n" + "\n" + "    classifiers=[\n"
                                + "        'Programming Language :: Python :: 3.8',\n"
                                + "        'Programming Language :: Python :: 3.9'\n"
                                + "    ],\n" + ")\n" + "";

                File f = tmppath.resolve("setup.py").toFile();
                FileWriter fw = new FileWriter(f);
                fw.write(setuppy);
                fw.close();

                // without readme, python complains
                f = tmppath.resolve("README").toFile();
                fw = new FileWriter(f);
                fw.write("");
                fw.close();

                // call python to build the package to be sure we have a correct package
                new Call(PythonVenv.PYTHON3, Arrays.asList("setup.py", "sdist"), 30000,
                                tmppath.toFile()).run();

                // -1 is the version number added py setup.py to the file
                return tmppath.resolve("dist/" + modulename + "-1.tar.gz").toFile();
        }

        @Override
        public String toString() {
                return "PyProgram[" + modules + "]";
        }
}