jpype1

JPype 1.6.0

This release introduces several important updates and fixes:

• Maven Module Structure: Java components have been restructured to follow the Maven module style, improving project organization and dependency management.
• JArray Registration: JArray is now properly registered as a Sequence, enhancing compatibility and usability.
• Float16 Conversion Fix: Corrected the conversion of float16 values, specifically addressing issues with subnormal numbers.
• Null String Handling: Resolved a segmentation fault that occurred when handling null Strings.
• List Method Fixes: Fixed bugs related to the concatenation and repetition methods for java.util.List.
• JProxy Enhancement: Improved JProxy to allow wrapping an existing Python object with a Java interface.
• Map Interface Bug Fix: Addressed an issue where using an interface derived from Map with JProxy would fail.
• JConversion Respect: Fixed a bug where JPype did not honor a JConversion between two Java classes.
• Direct Buffer Enhancement: Updated convertToDirectBuffer to support wrapping bytes and read-only memoryviews as read-only Java ByteBuffers.

These changes improve stability, compatibility, and usability across multiple components.

• Roll back agent change due to misbehaving JVM installs.
• Correct issues with non-ascii path for jdbc connections and forName.

What's Changed

• Cycle by @Thrameos in #1163
• Minor typos in the user guide by @pelson in #1171
• Make use of pyproject.toml for static project metadata by @pelson in #1133
• Fix error in 3.12 during exception handling by @Thrameos in #1180
• Fixing typo in userguide.rst by @ryanmkurtz in #1179
• Windows locale by @Thrameos in #1174
• Changes for numpy 2.0 to fix test matrix. by @Thrameos in #1196
• Fix misspelling in documentation by @kdombeck in #1192
• fix compatibility of jpype with setuptools==72.0.0 by @alexrashed in #1206
• Crash on windows exception during customizers by @Thrameos in #1199
• Update LICENSE by @clajo04 in #1211
• [ci] add jdks to test matrix by @marscher in #1131
• prevent misuse of PyTuple_Pack by @astrelsky in #1218
• Remove use of tp_new by @Thrameos in #1217
• fix JUnpickler BufferOverflowException by @tachyonicClock in #1220
• "Generic" JArray support by @astrelsky in #1214
• Fix IllegalArgumentException with non-ascii paths by @tachyonicClock in #1195
• Support extracting javadoc HTML files generated by Javadoc 17 by @GorgiAstro in #1200
• [ci] allow to download missing Python versions by @marscher in #1221
• Access to default methods in @JImplements by @Thrameos in #1182
• handle non ascii classpath with system classloader by @astrelsky in #1226
• free threaded build by @astrelsky in #1224
• Try to improve the Azure pipeline, and publish the intermediate wheels for debugging by @pelson in #1233
• Fix for GC on windows by @Thrameos in #1235
• Releases/1.5.1 by @Thrameos in #1234

New Contributors

• @ryanmkurtz made their first contribution in #1179
• @kdombeck made their first contribution in #1192
• @alexrashed made their first contribution in #1206
• @clajo04 made their first contribution in #1211
• @tachyonicClock made their first contribution in #1220
• @GorgiAstro made their first contribution in #1200

Full Changelog: v1.5.0...v1.5.1

• 1.5.0 - 2023-12-15

  • Support for Python 3.12

  • Switched __eq__ and __ne__ operator to use equals rather than compareTo for comparable objects to avoid exception when comparing object of different types.

  • Fixed segmentation fault when comparing Java Comparable to primitives.

  • Java exceptions that occur in inequality comparisons now map to Python TypeError.

  • Fixed crash when calling subscript on JArray.

  • Fixed direct byte buffers not reporting nbytes correctly when cast to memoryview.

  • Expand the defintion for Functional interface to include classes without FunctionInterface annotation.

  • Add additional matching level for derived types to resolve ambiguities when a derived type is used in place of base class when determining the method overload. This will resolve some previous ambiguities between methods.

• Fixed issue with startJVM changing locale settings.

  • Changes to support Python 3.11

  • Fix truncation of strings on null when using convert strings.

  • Replaced distutil with packaging

• Support for all different buffer type conversions.

  • Improved buffer transfers to numpy as guaranteed to match Java types. However, exact dtype for conversions is os/numpy version dependent.

  • Support for byte order channels on buffer transfers.

  • Byte size for buffers now fixed to Java definitions.

  • When directly accessing Java arrays using memory view, Python requires a cast from buffers. Required because Python does not support memory view alterations on non-native sizes.

  • Fix crash when comparing JChar.

    • Order handling for numerical operations with JChar fixed.

  • Improved matching for Java functors based on parameter count.

  • Dropped support for Python 3.5 and 3.6

  • dbapi2 handles drivers that don't support autocommit.

  • Fixed issue when Java classes with dunder methods such as __del__ caused conflicts in Python type system. Java method which match dunder patterns are longer translated to Python.

  • Fix issue with numpy arrays with no dimensions resulting in crash.

  • Support for user defined conversions for java.lang.Class and array types.

  • Fixed issue with ssize_t on Windows for Python 3.10.

• Fixes for memory issues found when upgrading to Python 3.10 beta.

  • Add additional diagnositics for importing of non-public class.

  • Fixed issue with classes with unsatified dependencies leading to a crash on windows.

  • Fixed a bug with arrays created using the short cut. The wrong type was being returned.

This is a bug release to correct defects found in the previous release. This version should add no additional functionality, though certain bug fixes will correct previous behaviors or add files which were incorrectly excluded due to packaging issues.

• JPype scans jar files and rebuilding missing directories to allow imports from stripped and obfuscated jar files. Previously certain build patterns for jars excluded directories which prevented the import system from functioning properly. This change should increase the number of jar files which can be imported successfully. This was the intended behavior for imports, but certain defects in the process prevented proper function.

• Missing stub files added to packaging. These were added in the last release, but the packaging system incorrectly excluded them from the build.

• Python 3.9 issues are resolved on Windows. A change in Python 3.9 made is so that the GIL is not held during library loading, thus static variables created are not valid. These variables have been moved to module initialization.

• aarch64 has been added to the build patterns for publication in this and future releases.

• Added builds for Python 3.9. Python 3.9 on Windows is currently failing due to issue in Python.

  • Fixed bug when importing from multi-release jars. The directory was being truncated to only those classes in the overlay.

  • addClassPath can add jar files after the JVM is started. The default loader for JPype class is org.jpype.classloader.DynamicClassLoader.

  • Build support of z/OS added.

  • Bug causing ambiguity between primitives and variadic arguments in method resolution was corrected.

  • Boolean was inadvertently left out of method resolution. boolean now properly matched with boxed types.

  • Support for PyInstaller was added.

• Linux binaries are now stripped for size.

  • Add importlib.util to address instability in Python importlib boot process. Certain versions of Python such as 3.9 appear to not properly load this module resulting in unexpected errors during startJVM.

This pull release corrects an issue in the build system resulting in incomplete wheels on linux. No other changes from 1.1.0.

• The wrapper for Throwable was getting the wrapper for Object rather than the expected wrapper resulting in odd conversions from Python classes.

  • Typos within the import system resulting in "jname" not found corrected.

  • ^C propagates to a KeyboardInterrupt properly.

  • Added cache to the method dispatch to bypass resolution of overloads. This reduces the cost of method resolution significantly especially if the same overload is hit repeatedly such as during loop operations.

  • Improved speed on transfer of lists, tuples, buffers to arrays of Java primitives by a factor of 4 to 100 depending on the data type. The conversion uses optimized path for memory buffers, rather than the Sequence API. When a Python buffer is encountered only the first element is checked for conversion as Python buffers are homogeneous.

  • Corrected symbol problem with Python 3.5.3. PySlice_Unpack was introduced in a later patch release and should not have been used.

  • shutdown The behavior log entry for changes on shutdown were lost in the 1.0 release. JPype now calls the JVM shutdown routine which tries to gracefully exit when shutdown is called. This results in several changes in behavior. Non daemon threads can now hold open the JVM until they have completed. Proxy calls will hold the shutdown until the call is completed but will receive an interrupt message. Files now close properly and will flush if the threads properly handle the exception. Resource clean up hooks and finalizers are executed. AtExit hooks in the JVM are called as spawned threads. Automatic attachment of threads by use of the JVM from Python are done as daemon but can be reattached as user threads on demand. Buggy code that fails to properly handle thread clean up will likely hang on shutdown. Additional documentation is located in the user guide.

  • A bug was reported with numpy.linalg.inv resulting in crashes. This was traced to an interaction with threading between the JVM and some compilations of numpy. The workaround appears to be calling numpy.linalg.inv prior to starting the JVM.

special note To all our friends on opennet.ru, please blame not the translator. Translating my mangled English diction and word order is torture enough. Dyslexics of the world untie!

This is a single issue patch release for compatibility with Python 3.8.4.

• Workarounds for Python 3.8.4 release. Python altered logic regarding the use of __setattr__ for object and type, preventing it from being used to alter derived classes. Also the checking for errors was delegated from the __setattr__ method so exception types on some sanity checks needed to be updated accordingly.

This release is to fix an issue in which the development release was accidentally published as the source release on PyPi. v0.7.4 built from source from PyPi and on the Anaconda distributions should be replaced with this version. Changes in this release include

• Updated documentation
• A revised release and testing process which should prevent similar issues in the future

This is a quick fix release to deal with a memory leak in array handling which allowed arrays to escape garbage collection when created from Python or as part of variable argument methods.

• Corrected a resource leak in arrays that affects array initialization, and variable argument methods.

• Upgraded diagnostic tracing and JNI checks to prevent future resource leaks.

This is a maintenance release correcting a number of issues from NumPy removal. Yet another stepping stone on the way to 1.0.

• Replaced type management system, memory management for internal classes is now completely in Java to allow enhancements for buffer support and revised type conversion system.

• Python module jpype.reflect will be removed in the next release.

• jpype.startJVM option convertStrings default will become False in the next release.

• Undocumented feature of using a Python type in JObject(obj, type=tp) is deprecated to support casting to Python wrapper types in Java in a future release.

• Dropped support for Cygwin platform.

• JFloat properly follows Java rules for conversion from JDouble. Floats outside of range map to inf and -inf.

• java.lang.Number converts automatically from Python and Java numbers. Java primitive types will cast to their proper box type when passed to methods and fields taking Number.

• java.lang.Object and java.lang.Number box signed, sized numpy types (int8, int16, int32, int64, float32, float64) to the Java boxed type with the same size automatically. Architecture dependent numpy types map to Long or Double like other Python types.

• Explicit casting using primitives such as JInt will not produce an OverflowError. Implicit casting from Python types such as int or float will.

• Returns for number type primitives will retain their return type information. These are derived from Python int and float types thus no change in behavior unless chaining from a Java methods which is not allowed in Java without a cast. JBoolean and JChar still produce Python types only.

• Add support for direct conversion of multi-dimensional primitive arrays with JArray.of(array, [dtype=type])

• java.nio.Buffer derived objects can convert to memoryview if they are direct. They can be converted to NumPy arrays with numpy.asarray(memoryview(obj)).

• Proxies created with @JImplements properly implement toString, hashCode, and equals.

• Proxies pass Python exceptions properly rather converting to java.lang.RuntimeException

• JProxy.unwrap() will return the original instance object for proxies created with JProxy. Otherwise will return the proxy.

• JProxy instances created with the convert=True argument will automatic unwrap when passed from Java to Python.

• JProxy only creates one copy of the invocation handler per garbage collection rather than once per use. Thus proxy objects placed in memory containers will have the same object id so long as Java holds on to it.

• @JImplements with keyword argument deferred can be started prior to starting the JVM. Methods are checked at first object creation.

• Fix bug that was causing java.lang.Comparable, byte[], and char[] to be unhashable.

• Fix bug causing segfault when throwing Exceptions which lack a default constructor.

• Fixed segfault when methods called by proxy have incorrect number of arguments.

• Fixed stack overflow crash on iterating ImmutableList

• java.util.Map conforms to Python collections.abc.Mapping API.

• java.lang.ArrayIndexOutOfBoundsException can be caught with IndexError for consistency with Python exception usage.

• java.lang.NullPointerException can be caught with ValueError for consistency with Python exception usage.

• Replaced type conversion system, type conversions test conversion once per type improving speed and increasing flexiblity.

• User defined implicit conversions can be created with @JConversion decorator on Python function taking Java class and Python object. Converter function must produce a Java class instance.

• pathlib.Path can be implicitly converted into java.lang.File and java.lang.Path.

• datetime.datatime can implicitly convert to java.time.Instant.

• dict and collections.abc.Mapping can convert to java.util.Map if all element are convertable to Java. Otherwise, TypeError is raised.

• list and collections.abc.Sequence can convert to java.util.Collection if all elements are convertable to Java. Otherwise, TypeError is raised.

• C++ and Java exceptions hold the traceback as a Python exception cause. It is no longer necessary to call stacktrace() to retrieve the traceback information.

  • Speed for call return path has been improved by a factor of 3.

  • Multidimensional array buffer transfers increase speed transfers to numpy substantially (orders of magnitude). Multidimension primitive transfers are read-only copies produced inside the JVM with C contiguous layout.

  • All exposed internals have been replaced with CPython implementations thus symbols __javaclass__, __javavalue__, and __javaproxy__ have been removed. A dedicated Java slot has been added to all CPython types derived from _jpype class types. All private tables have been moved to CPython. Java types must derive from the metaclass JClass which enforces type slots. Mixins of Python base classes is not permitted. Objects, Proxies, Exceptions, Numbers, and Arrays derive directly from internal CPython implementations.

  • Internal improvements to tracing and exception handling.

  • Memory leak in convertToDirectBuffer has been corrected.

  • Arrays slices are now a view which support writeback to the original like numpy array. Array slices are no longer covariant returns of list or numpy.array depending on the build procedure.

  • Array slices support steps for both set and get.

  • Arrays now implement __reversed__

  • Incorrect mapping of floats between 0 and 1 to False in setting Java boolean array members is corrected.

  • Java arrays now properly assert range checks when setting elements from sequences.

  • Java arrays support memoryview API and no longer required numpy to transfer buffer contents.

  • Numpy is no longer an optional extra. Memory transfer to numpy is available without compiling for numpy support.

  • JInterface is now a meta class. Use isinstance(cls, JInterface) to test for interfaces.

  • Fixed memory leak in Proxy invocation

  • Fixed bug with Proxy not converting when passed as an argument to Python functions during execution of proxies

  • Missing tlds "mil", "net", and "edu" added to default imports.

  • Enhanced error reporting for UnsupportedClassVersion during startup.

  • Corrections for collection methods to improve complience with Python containers.

    • java.util.Map gives KeyError if the item is not found. Values that are null still return None as expected. Use get() if empty keys are to be treated as None.

    • java.util.Collection __delitem__ was removed as it overloads oddly between remove(Object) and remove(int) on Lists. Use Java remove() method to access the original Java behavior, but a cast is strongly recommended to to handle the overload.

  • java.lang.IndexOutOfBoundsException can be caught with IndexError for complience when accessing java.util.List elements.

• Updated the keyword safe list for Python 3.

  • Automatic conversion of CharSequence from Python strings.

  • java.lang.AutoCloseable supports Python "with" statement.

  • Hash codes for boxed types work properly in Python 3 and can be used as dictionary keys again (same as JPype 0.6). Java arrays have working hash codes, but as they are mutable should not be used as dictionary keys. java.lang.Character, java.lang.Float, and java.lang.Double all work as dictionary keys, but due to differences in the hashing algorithm do not index to the same location as Python native types and thus may cause issues when used as dictionary keys.

  • Updated getJVMVersion to work with JDK 9+.

  • Added support for pickling of Java objects using optional module jpype.pickle

  • Fixed incorrect string conversion on exceptions. str() was incorrectly returning getMessage rather than toString.

  • Fixed an issue with JDK 12 regarding calling methods with reflection.

  • Removed limitations having to do with CallerSensitive methods. Methods affected are listed in caller-sensitive. Caller sensitive methods now receive an internal JPype class as the desut

  • Fixed segfault when converting null elements while accessing a slice from a Java object array.

  • PyJPMethod now supports the FunctionType API.

  • Tab completion with Jedi is supported. Jedi is the engine behind tab completion in many popular editors and shells such as IPython. Jedi version 0.14.1 is required for tab completion as earlier versions did not support annotations on compiled classes. Tab completion with older versions requires use of the IPython greedy method.

  • JProxy objects now are returned from Java as the Python objects that originate from. Older style proxy classes return the inst or dict. New style return the proxy class instance. Thus proxy classes can be stored on generic Java containers and retrieved as Python objects.

• Java reference counting has been converted to use JNI PushLocalFrame/PopLocalFrame. Several resource leaks were removed.

• java.lang.Class<>.forName() will now return the java.lang.Class. Work arounds for requiring the class loader are no longer needed. Customizers now support customization of static members.

• Support of java.lang.Class<>

• java.lang.Object().getClass() on Java objects returns a java.lang.Class rather than the Python class

• java.lang.Object().class on Java objects returns the python class as do all python objects

• java.lang.Object.class_ maps to the java statement 'java.lang.Object.class' and returns the java.lang.Class<java.lang.object>

• java.lang.Class supports reflection methods

• private fields and methods can be accessed via reflection

• annotations are avaiable via reflection

• Java objects and arrays will not accept setattr unless the attribute corresponds to a java method or field whith the exception of private attributes that begin with underscore.

• Added support for automatic conversion of boxed types.

• Boxed types automatically convert to python primitives.

• Boxed types automatically convert to java primitives when resolving functions.

• Functions taking boxed or primitives still resolve based on closest match.

• Python integer primitives will implicitly match java float and double as per Java specification.

• Added support for try with resources for java.lang.Closeable. Use python "with MyJavaResource() as resource:" statement to automatically close a resource at the end of a block.

This release makes the need for a Java development Kit (JDK) obsolete. A fallback JNI headers is provided and is used in case no JAVA_HOME environment variable is set to a JDK.

bug fix release, see changelog for more informations.

intermediate bug fix release addressing issue #64

A new OSX release is around the corner, time to add support for it!

Thanks to @rmangino!

new release to pypi.

• Rewritten Java Home directory Search by @marsam (#13, #12 and #7)
• Stylistic cleanups of setup.py