JPype is cross language bridge to allow Python programs full access to Java class libraries.
APACHE-2.0 License
Bot releases are visible (Hide)
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.
Published by Thrameos almost 2 years ago
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
Published by Thrameos over 2 years ago
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.
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.
Published by Thrameos over 3 years ago
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.
Published by Thrameos almost 4 years ago
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.
Published by Thrameos almost 4 years ago
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.
Published by Thrameos almost 4 years ago
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.
Published by Thrameos almost 4 years ago
This pull release corrects an issue in the build system resulting in incomplete wheels on linux. No other changes from 1.1.0.
Published by Thrameos almost 4 years ago
linux distribution were incomplete. Please use 1.1.1 release.
Correct bug resulting in reporting ambiguous overloads when resolving
methods with variadic arguments.
Ctrl+C behavior is switchable with interrupt flag to startJVM.
If True, process will halt on Ctrl-C. If False, the process
will transfer control to Python rather than halting. If
not specified JPype will assume false if Python is started as an
interactive shell.
Fixed crash with Ctrl+C when multiple exceptions were generated.
Removed extraneous exception when calling Ctrl+C before Java code is
executed for methods and fields.
Fixed memory leak with string cache.
Fixed crash when manually creating wrappers for anonymous classes.
Fixed reference count problem in stackframes used for exceptions.
Errors report *static*
when the matching with a static method
so that it is clear when a member method was called statically.
java.lang.String slices function like Python string slice.
Java packages now operate as normal Python modules. Removed restrictions
regarding setattr. All package instances for the same package name are
shared so that functionality added to one instance is shared wiht all
instances.
Published by Thrameos about 4 years ago
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!
Published by Thrameos over 4 years ago
This is a single issue patch release for compatibility with Python 3.8.4.
__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.Published by Thrameos over 4 years ago
JChar
is supported as a return type, thus rather than returning a string where a JChar
is expected. For compatibility JChar
is
derived from str
and implements implicit conversion to an int
when used in numeric operations. Therefore, it passes the return, argument, and field contracts. But that means it is no longer considered a numerical type to Python and thus isinstance(c, int)
is False. This is consistent with the Java type conversion rules.
Introduced Python operator for Java casting. In Java to cast to a type you would use (Type) obj
, but Python does not support anything similar. Therefore, we are enlisting the rarely used matmul
operator as to allow an easy way to cast an object to a Java type. When a cast to a Java type is required, use Type@obj
or (Type)@obj
.
Introduced array notation to create Java arrays. In earlier versions, JArray factory was required to make a new array type. But this is tedious to read. In Java the notation would be Type[]
to declare a type or new Type[sz]
to make a new array. Python does not directly support this notation, but it does allow for unspecified array sizes using a slice. All Java class types support Type[sz]
to create an array of a fixed size and Type[:]
to create an array type which can be instantiated later. This call be applied to multiple dimensions to create fixed sized arrays Type[s1][s2][s3]
to declare multi-dimension array types Type[:][:][:]
or to create a new multi dimensional array with unspecified dimensions Type[sz][:][:]
. Applying a slice with limits to a class is unsupported.
Java classes annotated with @FunctionalInterface
can be converted from any Python object that implements __call__
. This allows functions, lambdas, and class constructors to be used whereever Java accepts a lambda.
Deprecated class and functions were removed. JIterator
, use of JException
as a factory, get_default_jvm_path
, jpype.reflect
module.
Default for starting JVM is now to return Java strings rather than convert.
Python deprecated __int__
so implicit conversions between float and integer types will produce a TypeError
.
Use of JException
is discouraged. To catch all exceptions or test if an object is a Java exception type, use java.lang.Throwable
.
Chained Java exception causes are now reflected in the Python stackframes.
Use of JString
is discouraged. To create a Java string or test if an object is a Java string type, use java.lang.String
.
Updated the repr methods on Java classes.
java.util.List
completes the contract for collections.abc.Sequence
and collections.abc.MutableSequence
.
java.util.Collection
completes the contract for collections.abc.Collection
.
Java classes are closed and will raise TypeError
if extended in Python.
Handles Control-C gracefully. Previous versions crash whenever Java handles the Control-C signal as they would shutdown Java during a call. Now JPype will produce a InterruptedException
when returning from Java. Control-C will not break out of large Java procedures as currently implemented as Java does not have a specific provision for this.
Published by Thrameos over 4 years ago
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
Published by Thrameos over 4 years ago
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.
Published by Thrameos over 4 years ago
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.
Published by Thrameos over 4 years ago
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.
Published by Thrameos almost 5 years ago
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 :doc: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.
Published by marscher over 5 years ago
Doc strings are generated for classes and methods.
Complete rewrite of the core module code to deal unattached threads,
improved hardening, and member management. Massive number of internal
bugs were identified during the rewrite and corrected.
See the :doc:ChangeLog-0.7
for details of all changes.
API breakage:
Java strings conversion behavior has changed. The previous behavior was
switchable, but only the default convert to Python was working.
Converting to automatically lead to problems in which is was impossible
to work with classes like StringBuilder in Java. To convert a Java
string use str()
. Therefore, string conversion is currently selected
by a switch at the start of the JVM. The default shall be False
starting in JPype 0.8. New code is encouraged to use the future default
of False. For the transition period the default will be True with a
warning if not policy was selected to encourage developers to pick the
string conversion policy that best applies to their application.
Java exceptions are now derived from Python exception. The old wrapper
types have been removed. Catch the exception with the actual Java
exception type rather than JException
.
Undocumented exceptions issued from within JPype have been mapped to the
corresponding Python exception types such as TypeError
and
ValueError
appropriately. Code catching exceptions from previous
versions should be checked to make sure all exception paths are being
handled.
Undocumented property import of Java bean pattern get/set accessors was
removed as the default. It is available with import jpype.beans
, but
its use is discouraged.
API rework:
jpype.imports
works with Python 2.7.JProxy
code@JImplements
and @JOverload
@JImplementionFor
jpype.types
was introduced containing onlyfrom jpype.types import *
tosynchronized
using the Python with
statement now works
for locking of Java objects.
Previous bug in initialization of arrays from list has been
corrected.
Added extra verbiage to the to the raised exception when an overloaded
method could not be matched. It now prints a list of all possible method
signatures.
The following is now DEPRECATED
jpype.reflect.*
- All class information is available with .class_
JException
from string now issues a warning.The following is now REMOVED
JPypeReferenceQueue
. References are always handled withsetUsePythonThreadForDaemon()
JavaClass
and JavaObject
have been removed.promoted --install-option
to a --global-option
as it applies to the build as well
as install.
Added --enable-tracing
to setup.py to allow for compiling with tracing
for debugging.
Ant is required to build jpype from source, use --ant=
with setup.py
to direct to a specific ant.
Published by marscher over 6 years ago
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.
Published by marscher over 9 years ago