jep 4.2.0__tar.gz → 4.2.2__tar.gz

{jep-4.2.0/src/main/python/jep.egg-info → jep-4.2.2}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: jep
-Version: 4.2.0
+Version: 4.2.2
 Summary: Jep embeds CPython in Java
 Home-page: https://github.com/ninia/jep
 Author: Jep Developers
 Author-email: jep-project@googlegroups.com
 License: zlib/libpng
 Keywords: java
-Platform: UNKNOWN
 Classifier: License :: OSI Approved :: zlib/libpng License
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -21,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 License-File: LICENSE
 License-File: AUTHORS
@@ -66,8 +66,12 @@ Some benefits of embedding CPython in a JVM:
 
 Installation
 ------------
-Simply run ``pip install jep`` or download the source and run ``pip install .``.
-Building and installing require the JDK, Python, and optionally numpy to be installed beforehand.
+Simply run ``pip install --no-cache-dir --no-build-isolation jep`` or download
+the source and run ``pip install .``. Building and installing require the JDK,
+Python, setuptools, and optionally numpy to be installed beforehand. The 
+``--no-cache-dir`` and ``--no-build-isolation`` options are not strictly
+required, however those settings enable Jep to make customizations for your
+environment such as enabling numpy specific behavior if numpy is installed.
 
 Dependencies
 ------------
@@ -99,5 +103,3 @@ been resolved.
 
 
 *Jep Team*
-
-

{jep-4.2.0 → jep-4.2.2}/README.rst

@@ -39,8 +39,12 @@ Some benefits of embedding CPython in a JVM:
 
 Installation
 ------------
-Simply run ``pip install jep`` or download the source and run ``pip install .``.
-Building and installing require the JDK, Python, and optionally numpy to be installed beforehand.
+Simply run ``pip install --no-cache-dir --no-build-isolation jep`` or download
+the source and run ``pip install .``. Building and installing require the JDK,
+Python, setuptools, and optionally numpy to be installed beforehand. The 
+``--no-cache-dir`` and ``--no-build-isolation`` options are not strictly
+required, however those settings enable Jep to make customizations for your
+environment such as enabling numpy specific behavior if numpy is installed.
 
 Dependencies
 ------------

{jep-4.2.0 → jep-4.2.2}/commands/__init__.py

@@ -1,5 +1,8 @@
-# https://github.com/pypa/setuptools/issues/2928
-from distutils.command.build import build
+try:
+    from setuptools.command.build import build
+except ImportError:
+    from distutils.command.build import build
+
 from commands.java import build_java
 
 class jep_build(build):

{jep-4.2.0 → jep-4.2.2}/commands/java.py

@@ -10,9 +10,10 @@ import fnmatch
 import traceback
 import sys
 import logging
+from pathlib import Path
 
 from commands.util import configure_error
-from commands.util import is_osx
+from commands.util import is_osx, is_linux
 from commands.util import shell
 from commands.util import CommandFailed
 from commands.util import warning
@@ -48,6 +49,12 @@ def get_java_home():
         except CommandFailed:
             traceback.print_exc()
 
+    if is_linux():
+        javac_path = shutil.which('javac')
+        if javac_path is not None:
+            _java_home = Path(javac_path).resolve().parent.parent.as_posix()
+            return _java_home
+
     configure_error(
         'Please set the environment variable JAVA_HOME to a path containing the JDK.')
 

{jep-4.2.0 → jep-4.2.2}/commands/util.py

@@ -26,6 +26,10 @@ def is_bsd():
     return 'bsd' in get_platform()
 
 
+def is_linux():
+    return "linux" in get_platform()
+
+
 class CommandFailed(Exception):
     """
     The command failed to run for any reason

{jep-4.2.0 → jep-4.2.2}/pom.xml

@@ -6,7 +6,7 @@
 
   <groupId>black.ninia</groupId>
   <artifactId>jep</artifactId>
-  <version>4.2.0</version>
+  <version>4.2.2</version>
   <packaging>jar</packaging>
 
   <name>Java Embedded Python</name>
@@ -39,7 +39,7 @@
   <scm>
     <connection>scm:git:git://github.com/ninia/jep.git</connection>
     <developerConnection>scm:git:ssh://github.com:ninia/jep.git</developerConnection>
-    <url>https://github.com/ninia/jep/tree/v4.2.0</url>
+    <url>https://github.com/ninia/jep/tree/v4.2.2</url>
    </scm>
 
   <properties>

{jep-4.2.0 → jep-4.2.2}/release_notes/4.2-notes.rst

@@ -28,7 +28,7 @@ situations where duck typing is not good enough and a dictionary is required.
 
 Additions of PyBuiltins
 ***********************
-The `PyBuiltins <http://ninia.github.io/jep/javadoc/4.2/jep/python/PyBuiltin.html>`_
+The `PyBuiltins <http://ninia.github.io/jep/javadoc/4.2/jep/python/PyBuiltins.html>`_
 class provides makes it easier to call some of the builtin Python functions
 from Java.
 

{jep-4.2.0 → jep-4.2.2}/setup.py

@@ -29,11 +29,18 @@ numpy_include = []
 numpy_found = 0
 try:
    import numpy
-   include_path = os.path.join(numpy.__path__[0], 'core', 'include')
-   if os.path.exists(include_path):
-      print('numpy include found at', include_path)
+   numpy1_include_path = os.path.join(numpy.__path__[0], 'core', 'include')
+   numpy2_include_path = os.path.join(numpy.__path__[0], '_core', 'include')
+   if os.path.exists(numpy1_include_path):
+      print('numpy include found at', numpy1_include_path)
       numpy_found = 1
-      numpy_include = [include_path]
+      numpy_include = [numpy1_include_path]
+   elif os.path.exists(numpy2_include_path):
+      print('numpy include found at', numpy2_include_path)
+      numpy_found = 1
+      numpy_include = [numpy2_include_path]
+   else:
+      print('numpy include not found')
 except ImportError:
    print('numpy not found, running without numpy support')
 
@@ -100,6 +107,7 @@ if __name__ == '__main__':
                        'Programming Language :: Python :: 3.10',
                        'Programming Language :: Python :: 3.11',
                        'Programming Language :: Python :: 3.12',
+                       'Programming Language :: Python :: 3.13',
                        'Programming Language :: Python :: Implementation :: CPython',
                       ],
           ext_modules=[

{jep-4.2.0 → jep-4.2.2}/src/main/c/Include/pyembed.h

@@ -44,7 +44,7 @@ typedef struct __JepThread JepThread;
 
 
 void pyembed_preinit(JNIEnv*, jint, jint, jint, jint, jint, jint, jint,
-                     jstring);
+                     jstring, jstring);
 void pyembed_startup(JNIEnv*, jobjectArray);
 void pyembed_shutdown(JavaVM*);
 void pyembed_shared_import(JNIEnv*, jstring);

{jep-4.2.0 → jep-4.2.2}/src/main/c/Jep/maininterpreter.c

@@ -47,11 +47,12 @@ JNIEXPORT void JNICALL Java_jep_MainInterpreter_setInitParams
  jint optimizeFlag,
  jint dontWriteBytecodeFlag,
  jint hashRandomizationFlag,
- jstring pythonHome)
+ jstring pythonHome,
+ jstring programName)
 {
     pyembed_preinit(env, noSiteFlag, noUserSiteDirectory, ignoreEnvironmentFlag,
                     verboseFlag, optimizeFlag, dontWriteBytecodeFlag,
-                    hashRandomizationFlag, pythonHome);
+                    hashRandomizationFlag, pythonHome, programName);
 }
 
 /*

{jep-4.2.0 → jep-4.2.2}/src/main/c/Jep/pyembed.c

@@ -239,7 +239,8 @@ void pyembed_preinit(JNIEnv *env,
                      jint optimizeFlag,
                      jint dontWriteBytecodeFlag,
                      jint hashRandomizationFlag,
-                     jstring pythonHome)
+                     jstring pythonHome,
+                     jstring programName)
 {
     if (noSiteFlag >= 0) {
         Py_NoSiteFlag = noSiteFlag;
@@ -270,6 +271,14 @@ void pyembed_preinit(JNIEnv *env,
         // Python documentation says that the string should not be changed for
         // the duration of the program so it can never be freed.
     }
+    if (programName) {
+        const char* nameAsUTF = (*env)->GetStringUTFChars(env, programName, NULL);
+        wchar_t* nameForPython = Py_DecodeLocale(nameAsUTF, NULL);
+        (*env)->ReleaseStringUTFChars(env, programName, nameAsUTF);
+        Py_SetProgramName(nameForPython);
+        // Python documentation says that the string should not be changed for
+        // the duration of the program so it can never be freed.
+    }
 }
 
 /*
@@ -561,7 +570,7 @@ void pyembed_shared_import(JNIEnv *env, jstring module)
 intptr_t pyembed_thread_init(JNIEnv *env, jobject cl, jobject caller,
                              jboolean hasSharedModules, jboolean usesubinterpreter,
                              jboolean isolated, jint useMainObmalloc, jint allowFork,
-			     jint allowExec, jint allowThreads, jint allowDaemonThreads,
+                             jint allowExec, jint allowThreads, jint allowDaemonThreads,
                              jint checkMultiInterpExtensions, jint ownGIL)
 {
     JepThread *jepThread;
@@ -587,8 +596,8 @@ intptr_t pyembed_thread_init(JNIEnv *env, jobject cl, jobject caller,
         PyEval_AcquireThread(mainThreadState);
 
 #if PY_MAJOR_VERSION > 3 || PY_MINOR_VERSION >= 12
-        PyInterpreterConfig config; 
-	if (isolated) {
+        PyInterpreterConfig config;
+        if (isolated) {
             config = (PyInterpreterConfig) _PyInterpreterConfig_INIT;
         } else {
             config = (PyInterpreterConfig) _PyInterpreterConfig_LEGACY_INIT;
@@ -703,6 +712,7 @@ void pyembed_thread_close(JNIEnv *env, intptr_t _jepThread)
     Py_DECREF(key);
 
     Py_CLEAR(jepThread->globals);
+    PyGC_Collect();
 
     if (jepThread->classloader) {
         (*env)->DeleteGlobalRef(env, jepThread->classloader);

{jep-4.2.0 → jep-4.2.2}/src/main/c/Jep/python/jep_object.c

@@ -114,6 +114,7 @@ JNIEXPORT void JNICALL Java_jep_python_PyObject_setAttr
     }
 
 EXIT:
+    Py_XDECREF(pyAttr);
     PyEval_ReleaseThread(jepThread->tstate);
     release_utf_char(env, str, attrName);
 }

{jep-4.2.0 → jep-4.2.2}/src/main/c/Objects/pyjtype.c

@@ -32,6 +32,13 @@ static PyTypeObject PyJType_Type;
 static PyTypeObject* pyjtype_get_cached(JNIEnv*, PyObject*, jclass);
 static int addMethods(JNIEnv*, PyObject*, jclass);
 
+/*
+* Flag to indicate if methods have been added to static types. Most types are
+* reinitialized for each interpreter but static types are shared between
+* interpreters and must be initialized only once.
+*/
+static int staticTypesInitialized = 0;
+
 /*
  * Populate pyjmethods for a type and add it to the cache. This is for custom
  * types with extra logic in c since we are not able to add pyjmethods before
@@ -127,12 +134,24 @@ static int populateCustomTypeDict(JNIEnv *env, PyObject* fqnToPyType)
                            &PyJObject_Type)) {
         return -1;
     }
-    /* TODO In python 3.8 buffer protocol was added to spec so pybuffer type can use a spec */
-    if (!addCustomTypeToTypeDict(env, fqnToPyType, JBUFFER_TYPE, &PyJBuffer_Type)) {
-        return -1;
-    }
-    if (!addCustomTypeToTypeDict(env, fqnToPyType, JOBJECT_TYPE, &PyJObject_Type)) {
-        return -1;
+    if (staticTypesInitialized) {
+        if (PyDict_SetItemString(fqnToPyType, PyJBuffer_Type.tp_name,
+                                 (PyObject * ) &PyJBuffer_Type)) {
+            return -1;
+        }
+        if (PyDict_SetItemString(fqnToPyType, PyJObject_Type.tp_name,
+                                 (PyObject * ) &PyJObject_Type)) {
+            return -1;
+        }
+    } else {
+        /* TODO In python 3.8 buffer protocol was added to spec so pybuffer type can use a spec */
+        if (!addCustomTypeToTypeDict(env, fqnToPyType, JBUFFER_TYPE, &PyJBuffer_Type)) {
+            return -1;
+        }
+        if (!addCustomTypeToTypeDict(env, fqnToPyType, JOBJECT_TYPE, &PyJObject_Type)) {
+            return -1;
+        }
+        staticTypesInitialized = 1;
     }
     return 0;
 }
@@ -297,10 +316,10 @@ static int addMethods(JNIEnv* env, PyObject* dict, jclass clazz)
             if (isAbstract) {
                 if (oneAbstractPyJMethod) {
                     /*
-		     * If there is already one abstract method and this method is also
-		     * abstract then this isn't a functional interface and there is no need
-		     * to keep track of abstract methods.
-		     */
+                    * If there is already one abstract method and this method is also
+                    * abstract then this isn't a functional interface and there is no need
+                    * to keep track of abstract methods.
+                    */
                     functionalInterface = JNI_FALSE;
                     oneAbstractPyJMethod = NULL;
                 } else {
@@ -440,7 +459,7 @@ static PyTypeObject* pyjtype_get_new(JNIEnv *env, PyObject *fqnToPyType,
          * See https://docs.python.org/3/library/functions.html#type
          */
         type = (PyTypeObject*) PyObject_CallFunctionObjArgs((PyObject*) &PyJType_Type,
-                shortName, bases, dict, NULL);
+               shortName, bases, dict, NULL);
     }
     Py_DECREF(bases);
     Py_DECREF(dict);

jep-4.2.2/src/main/java/jep/AllowPythonClassEnquirer.java

@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) 2024 JEP AUTHORS.
+ *
+ * This file is licensed under the the zlib/libpng License.
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ * 
+ *     1. The origin of this software must not be misrepresented; you
+ *     must not claim that you wrote the original software. If you use
+ *     this software in a product, an acknowledgment in the product
+ *     documentation would be appreciated but is not required.
+ * 
+ *     2. Altered source versions must be plainly marked as such, and
+ *     must not be misrepresented as being the original software.
+ * 
+ *     3. This notice may not be removed or altered from any source
+ *     distribution.
+ */
+package jep;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * <p>
+ * A {@link ClassEnquirer} that defines specific packages as Python packages.
+ * This implementation takes a delegate ClassEnquirer to delegate all import
+ * determinations as Java or Python except in the cases of the specific Python
+ * package names provided. Imports of the specified packages in the embedded
+ * Python interpreter will use the Python importer and not the Java importer.
+ * This is useful when you have package name conflicts between Java and Python.
+ * Some examples are projects like py4j and tensorflow which have Python package
+ * names matching Java package names. In those cases, using the default
+ * ClassEnquirer of {@link ClassList} will lead to the Java packages on the
+ * classpath taking precedence on imports instead of the Python package. That
+ * can be solved by using this ClassEnquirer with a delegate of ClassList's
+ * instance.
+ * </p>
+ * 
+ * @author Nate Jensen
+ * 
+ * @since 4.2.1
+ */
+public class AllowPythonClassEnquirer implements ClassEnquirer {
+
+    protected ClassEnquirer delegate;
+
+    protected Set<String> pyPkgNames = new HashSet<>();
+
+    /**
+     * Constructor
+     * 
+     * @param delegate
+     *            the ClassEnquirer instance to delegate method calls to except
+     *            in the case of the specified Python package names
+     * @param pythonPackageNames
+     *            the names of Python packages that should not be treated as a
+     *            potential import from Java and instead should immediately
+     *            default to being imported by the normal Python importer
+     */
+    public AllowPythonClassEnquirer(ClassEnquirer delegate,
+            String... pythonPackageNames) {
+        this.delegate = delegate;
+        for (String pyPkg : pythonPackageNames) {
+            pyPkgNames.add(pyPkg);
+        }
+    }
+
+    @Override
+    public boolean isJavaPackage(String name) {
+        for (String pyPkg : pyPkgNames) {
+            if (name.equals(pyPkg) || name.startsWith(pyPkg + ".")) {
+                return false;
+            }
+        }
+
+        return delegate.isJavaPackage(name);
+    }
+
+    @Override
+    public String[] getClassNames(String pkgName) {
+        return delegate.getClassNames(pkgName);
+    }
+
+    @Override
+    public String[] getSubPackages(String pkgName) {
+        return delegate.getSubPackages(pkgName);
+    }
+
+}

{jep-4.2.0 → jep-4.2.2}/src/main/java/jep/ClassEnquirer.java

@@ -48,7 +48,7 @@ public interface ClassEnquirer {
      * Java packages unless a ClassEnquirer explicitly chooses to include them.
      */
     public static final String[] RESTRICTED_PKG_NAMES = new String[] { "io",
-            "re" };
+            "re", "py4j" };
 
     /**
      * Checks if the name is likely available in Java as a package. A return

{jep-4.2.0 → jep-4.2.2}/src/main/java/jep/ClassList.java

@@ -127,8 +127,11 @@ public class ClassList implements ClassEnquirer {
                         String[] relativePaths = classpath.split(" ");
 
                         for (String relativePath : relativePaths) {
-                            String path = file.getParent() + File.separator
-                                    + relativePath;
+                            String path = relativePath;
+                            String parent = file.getParent();
+                            if (parent != null) {
+                                path = parent + File.separator + relativePath;
+                            }
                             if (!seen.contains(path)) {
                                 queue.add(path);
                                 seen.add(path);

{jep-4.2.0 → jep-4.2.2}/src/main/java/jep/Jep.java

@@ -152,7 +152,9 @@ public abstract class Jep implements Interpreter {
         boolean hasSharedModules = config.sharedModules != null
                 && !config.sharedModules.isEmpty();
 
-        if (hasSharedModules && config.subInterpOptions.useMainObmalloc == 0) {
+        if (hasSharedModules && config.subInterpOptions.isolated) {
+            throw new JepException("Shared modules cannot be used with isolated interpreters.");
+        } else if (hasSharedModules && config.subInterpOptions.useMainObmalloc == 0) {
             throw new JepException("Shared modules can only be used with a shared allocator.");
         }
 
@@ -160,10 +162,10 @@ public abstract class Jep implements Interpreter {
         SubInterpreterOptions interpOptions = config.subInterpOptions;
         this.tstate = init(this.classLoader, hasSharedModules,
                 useSubInterpreter, interpOptions.isolated,
-		interpOptions.useMainObmalloc,
+                interpOptions.useMainObmalloc,
                 interpOptions.allowFork, interpOptions.allowExec,
                 interpOptions.allowThreads, interpOptions.allowDaemonThreads,
-                interpOptions.checkMultiInterpeExtensions,
+                interpOptions.checkMultiInterpExtensions,
                 interpOptions.ownGIL);
         threadUsed.set(true);
         this.thread = Thread.currentThread();
@@ -438,17 +440,40 @@ public abstract class Jep implements Interpreter {
         }
 
         if (isSubInterpreter) {
-            exec("import sys");
-            Boolean hasThreads = getValue("'threading' in sys.modules",
-                    Boolean.class);
-            if (hasThreads.booleanValue()) {
-                Integer count = getValue(
-                        "sys.modules['threading'].active_count()",
-                        Integer.class);
-                if (count.intValue() > 1) {
-                    throw new JepException(
-                            "All threads must be stopped before closing Jep.");
-                }
+            /*
+             * All background threads must complete before closing an
+             * interpreter.
+             *
+             * If threading is not already imported then there are no other
+             * threads so avoid importing threading because that creates new
+             * objects that aren't needed.
+             *
+             * In recent Python versions(>=3.13) there will always be at least
+             * 2 active threads here, the main thread on the main interpreter
+             * and this thread running the sub-interpreter.
+             *
+             * In older versions of python the minimum number of active threads
+             * should be 1 because each sub-interpreter would treat the first
+             * thread on that interpreter as the main thread.
+             *
+             * This behavior change in python was caused by
+             * https://github.com/python/cpython/issues/114271
+             */  
+            exec("def _check_single_thread():\n" +
+                 "  import sys\n" +
+                 "  if 'threading' in sys.modules:\n" +
+                 "    import threading\n" +
+                 "    if sys.version_info.major == 3 \\\n" +
+                 "          and sys.version_info.minor < 13:\n" +
+                 "      return threading.active_count() <= 1\n" +
+                 "    else:\n" +
+                 "      return threading.active_count() <= 2\n" +
+                 "  else:\n" +
+                 "    return True\n");
+            Boolean singleThread = getValue("_check_single_thread()", Boolean.class);
+            if (!singleThread.booleanValue()) {
+                throw new JepException(
+                        "All threads must be stopped before closing Jep.");
             }
         }
 

{jep-4.2.0 → jep-4.2.2}/src/main/java/jep/JepConfig.java

@@ -223,4 +223,14 @@ public class JepConfig {
         return new SubInterpreter(this);
     }
 
+    @Override
+    public String toString() {
+        return "JepConfig [interactive=" + interactive + ", includePath="
+                + includePath + ", classLoader=" + classLoader
+                + ", classEnquirer=" + classEnquirer + ", redirectStdout="
+                + redirectStdout + ", redirectStderr=" + redirectStderr
+                + ", sharedModules=" + sharedModules + ", subInterpOptions="
+                + subInterpOptions + "]";
+    }
+
 }

{jep-4.2.0 → jep-4.2.2}/src/main/java/jep/MainInterpreter.java

@@ -138,7 +138,7 @@ public final class MainInterpreter implements AutoCloseable {
             setInitParams(pyConfig.noSiteFlag, pyConfig.noUserSiteDirectory,
                     pyConfig.ignoreEnvironmentFlag, pyConfig.verboseFlag,
                     pyConfig.optimizeFlag, pyConfig.dontWriteBytecodeFlag,
-                    pyConfig.hashRandomizationFlag, pyConfig.pythonHome);
+                    pyConfig.hashRandomizationFlag, pyConfig.pythonHome, pyConfig.programName);
         }
 
         thread = new Thread("JepMainInterpreter") {
@@ -293,7 +293,7 @@ public final class MainInterpreter implements AutoCloseable {
     private static native void setInitParams(int noSiteFlag,
             int noUserSiteDiretory, int ignoreEnvironmentFlag, int verboseFlag,
             int optimizeFlag, int dontWriteBytecodeFlag,
-            int hashRandomizationFlag, String pythonHome);
+            int hashRandomizationFlag, String pythonHome, String programName);
 
     private static native void initializePython(String[] mainInterpreterArgv);
 

{jep-4.2.0 → jep-4.2.2}/src/main/java/jep/PyConfig.java

@@ -35,6 +35,12 @@ package jep;
  */
 public class PyConfig {
 
+    /*
+     * -1 is used to indicate not set, in which case we will not set it in the
+     * native code and the setting will be Python's default. A value of 0 or
+     * greater will cause the value to be set in the native code.
+     */
+
     protected int noSiteFlag = -1;
 
     protected int noUserSiteDirectory = -1;
@@ -51,6 +57,8 @@ public class PyConfig {
 
     protected String pythonHome;
 
+    protected String programName;
+
     /**
      * Set the Py_NoSiteFlag variable on the python interpreter. This
      * corresponds to the python "-S" flag and will prevent the "site" module
@@ -149,7 +157,7 @@ public class PyConfig {
     }
 
     /**
-     * Set the home location on the python interpreter. THis is the location of
+     * Set the home location on the python interpreter. This is the location of
      * the standard python libraries. This corresponds to the environment
      * variable PYTHONHOME.
      * 
@@ -162,4 +170,27 @@ public class PyConfig {
         return this;
     }
 
+    /**
+     * Set the Py_SetProgramName variable on the python interpreter. This is
+     * used to initialize executable and in early error messages during python
+     * initialization.
+     * 
+     * @param programName
+     *            the name of the executable python program.
+     * @return a reference to this PyConfig
+     */
+    public PyConfig setProgramName(String programName) {
+        this.programName = programName;
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        return "PyConfig [noSiteFlag=" + noSiteFlag + ", noUserSiteDirectory=" + noUserSiteDirectory
+                + ", ignoreEnvironmentFlag=" + ignoreEnvironmentFlag + ", verboseFlag=" + verboseFlag
+                + ", optimizeFlag=" + optimizeFlag + ", dontWriteBytecodeFlag=" + dontWriteBytecodeFlag
+                + ", hashRandomizationFlag=" + hashRandomizationFlag + ", pythonHome=" + pythonHome + ", programName="
+                + programName + "]";
+    }
+
 }

{jep-4.2.0 → jep-4.2.2}/src/main/java/jep/Run.java

@@ -123,7 +123,7 @@ public class Run {
         }
 
         // setup argv
-        StringBuffer b = new StringBuffer("[");
+        StringBuilder b = new StringBuilder("[");
         // always the first arg
         b.append("'" + file + "',");
         // trailing comma is okay