JPype

https://jpype.readthedocs.io/en/latest/
Admin
JPype is a Python module that provides full, high-performance access to Java from within Python by...
Tokens:217,193
Snippets:1,788
Trust Score:8.3
Update:1 week ago
Show doc for...
Tokens:
Raw
### Complete JPype example (hello_jpype.py)

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Full example that starts the JVM, imports java.lang.String, and prints an uppercase string. Save as hello_jpype.py and run with python hello_jpype.py.

```python
import jpype
import jpype.imports

# Start the JVM
jpype.startJVM(classpath=["../jar/*","../classes","com.amce-1.0.jar"])

# Import Java classes
from java.lang import String

# Use the Java String class
java_string = String("Hello from Java!")
print(java_string.toUpperCase())  # Output: HELLO FROM JAVA!
```

--------------------------------

### Install built JPype wheel

Source: https://jpype.readthedocs.io/en/latest/install.html

Installs the wheel produced by the build step.

```bash
pip install /path/to/wheel
```

--------------------------------

### JPype script with imports after startJVM (Autopep8 example)

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Shows the recommended import order for JPype: import jpype and jpype.imports, start the JVM, then import Java classes. Autopep8 may reorder these imports, causing failures.

```python
import jpype
import jpype.imports

jpype.startJVM()

from gov.llnl.math import DoubleArray
```

--------------------------------

### Java example for database access

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

A Java example showing how to connect to a database using a custom driver. It is provided as a reference to be ported to Python.

```java
package com.paying.customer;

import com.paying.customer.DataBase

public class MyExample {
   public void main(String[] args) {
     Database db = new Database("our_records");
     try (DatabaseConnection c = db.connect())
     {
        c.runQuery();
        while (c.hasRecords())
        {
          Record record = db.nextRecord();
          ...
        }
     }
  }
}
```

--------------------------------

### Install JPype via pip

Source: https://jpype.readthedocs.io/en/latest/userguide.html

Install JPype1 using pip.

```bash
pip install JPype1

```

--------------------------------

### Start JVM in Python

Source: https://jpype.readthedocs.io/en/latest/_sources/quickguide.rst.txt

Shows the initial steps to start the JVM with JPype: import the module, enable Java imports, pull in types, and launch the JVM.

```python
# Import module
import jpype

# Enable Java imports
import jpype.imports

# Pull in types
from jpype.types import *

# Launch the JVM
jpype.startJVM()
```

--------------------------------

### Start JVM with manual JVM path

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Starts the JVM by specifying the JVM path manually as the first argument to startJVM(). Used when automatic detection fails.

```python
jpype.startJVM('/path/to/libjvm.so', classpath=['lib/*'])
```

--------------------------------

### Start JVM and load serialized Java object

Source: https://jpype.readthedocs.io/en/latest/userguide.html

Boilerplate to start the JVM with a classpath and load a serialized Java object using java.nio.file and java.io.ObjectInputStream.

```python
import jpype
import jpype.imports

jpype.startJVM(classpath = ['jars/*', 'test/classes'])

from java.nio.file import Files, Paths
from java.io import ObjectInputStream

with Files.newInputStream(Paths.get("myobject.ser")) as stream:
    ois = ObjectInputStream(stream)
    obj = ois.readObject()

print(obj)  # prints org.bigstuff.MyObject@7382f612

```

--------------------------------

### Start JVM with third-party jar and javadoc for Javadoc

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Starts the JVM with both a jar and its javadoc archive on the classpath to access third-party Javadoc. Include both files as a list.

```java
import jpype
jpype.startJVM(classpath=['gson-2.8.5.jar', 'gson-2.8.5-javadoc.jar'])
```

--------------------------------

### Install JPype from GitHub master with pip

Source: https://jpype.readthedocs.io/en/latest/install.html

Installs the current development version from the GitHub repository. The git version does not include a prebuilt jar, so the JDK is required.

```bash
pip install git+https://github.com/jpype-project/jpype.git
```

--------------------------------

### Install latest JPype with pip

Source: https://jpype.readthedocs.io/en/latest/install.html

Builds and installs JPype from the source or binary distribution using pip.

```bash
pip install JPype1
```

--------------------------------

### Start the JVM with jpype.startJVM

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

JPype requires the JVM to be started before any Java interaction. Calls before startJVM will fail.

```python
import jpype

# Start the JVM
jpype.startJVM(classpath=[])
```

--------------------------------

### jpype.startJVM

Source: https://jpype.readthedocs.io/en/latest/api.html

Starts a Java Virtual Machine with configurable arguments, classpath, and options. It raises OSError if the JVM cannot be started or is already running, and TypeError on conflicting arguments.

```APIDOC
## jpype.startJVM

### Description
Starts a Java Virtual Machine. Without options it will start the JVM with the default classpath and jvmpath. The default classpath is determined by `jpype.getClassPath()`. The default jvmpath is determined by `jpype.getDefaultJVMPath()`.

### Method
Function call

### Signature
`jpype.startJVM(*jvmargs: str, jvmpath: Optional[PathOrStr] = None, classpath: Union[Sequence[PathOrStr], PathOrStr, None] = None, ignoreUnrecognized: bool = False, convertStrings: bool = False, interrupt: bool = True, minimum_version: Optional[str] = None) -> None`

### Parameters
#### Positional Arguments
- **jvmargs** (str) - Required - Arguments to give to the JVM. The first argument may be the path to the JVM.

#### Keyword Arguments
- **jvmpath** (str, PathLike) - Optional - Path to the jvm library file, typically one of (`libjvm.so`, `jvm.dll`, …). Using None will apply the default jvmpath.
- **classpath** (str, PathLike, [str, PathLike]) - Optional - Set the classpath for the JVM. This will override any classpath supplied in the arguments list. A value of None will give no classpath to JVM.
- **ignoreUnrecognized** (bool) - Optional - Option to ignore invalid JVM arguments. Default is False.
- **convertStrings** (bool) - Optional - Option to force Java strings to cast to Python strings. This option is to support legacy code for which conversion of Python strings was the default. This will globally change the behavior of all calls using strings, and a value of True is NOT recommended for newly developed code.
- **interrupt** (bool) - Optional - Option to install ^C signal handlers. If True then ^C will stop the process, else ^C will transfer control to Python rather than halting. If not specified will be False if Python is started as an interactive shell.

### Raises
- **OSError** – if the JVM cannot be started or is already running.
- **TypeError** – if a keyword argument conflicts with the positional arguments.

### Returns
None
```

--------------------------------

### Install built wheel and test JPype

Source: https://jpype.readthedocs.io/en/latest/_sources/install.rst.txt

Installs the built wheel and optionally runs the test suite with pytest. The test bench requires JDK to build.

```bash
pip install /path/to/wheel
```

```bash
python -m pytest
```

--------------------------------

### setupGuiEnvironment example for JavaFX

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Shows how to use setupGuiEnvironment to launch a GUI application, ensuring cross-platform compatibility. The callback schedules a task on the JavaFX Application Thread.

```python
from jpype import setupGuiEnvironment
from javafx.application import Platform

def say_hello_later():
    """Test function for scheduling a task on the JavaFX Application Thread."""
    print("Hello from JavaFX!")

def launch_gui():
    """Launch the GUI application."""
    # Example: Schedule a task on the JavaFX Application Thread
    Platform.runLater(say_hello_later)
    print("GUI launched")

# Use setupGuiEnvironment to ensure cross-platform compatibility
setupGuiEnvironment(launch_gui)
```

--------------------------------

### Run hello_jpype.py

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Command to run the complete example script.

```bash
python hello_jpype.py
```

--------------------------------

### Enable Java imports and start JVM

Source: https://jpype.readthedocs.io/en/latest/_sources/imports.rst.txt

Import jpype.imports to enable Java imports, then start the JVM before importing Java classes. This setup is required for all subsequent Java imports.

```python
import jpype
import jpype.imports  # Enable Java imports

# Start the JVM
jpype.startJVM()

# Now you can import Java classes
import java.lang
from java.util import ArrayList
```

--------------------------------

### Python port of Java database example

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Python code using JPype to start the JVM, import a Java module, and interact with a database. It mirrors the Java example and is intended to be run in an interactive window.

```python
# Boiler plate stuff to start the module
import jpype
import jpype.imports
from jpype.types import *

# Launch the JVM
jpype.startJVM(classpath=['jars/database.jar'])

# import the Java modules
from com.paying.customer import DataBase

# Copy in the patterns from the guide to replace the example code
db = Database("our_records")
with db.connect() as c:
    c.runQuery()
    while c.hasRecords():
        record = db.nextRecord()
        ...
```

--------------------------------

### Use a Java HashMap with Pythonic dictionary operations

Source: https://jpype.readthedocs.io/en/latest/userguide.html

Java Map classes behave like Python dictionaries. This example shows putting, getting, deleting, and getting length using Python syntax.

```python
from java.util import HashMap

jmap = HashMap()
jmap.put("key1", "value1")
jmap.put("key2", "value2")

print(jmap["key1"])  # Output: value1
del jmap["key2"]     # Remove "key2"
print(len(jmap))     # Output: 1

```

--------------------------------

### setupGuiEnvironment(cb)

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Ensures GUI applications run correctly across all platforms by handling macOS's main thread event loop requirement and providing consistent behavior on Linux and Windows. It takes a callback function that initializes and launches the GUI application.

```APIDOC
## setupGuiEnvironment(cb)

### Description
`setupGuiEnvironment` ensures that GUI applications can run correctly across all platforms. It is specifically designed to address macOS's requirement for the main thread to run the event loop, but it is also recommended for Swing and JavaFX applications on Linux and Windows to maintain cross-platform compatibility and proper threading behavior.

### Method
Function call

### Endpoint
setupGuiEnvironment(cb)

### Parameters
- **cb** (callable) - Required - A callback function that initializes and launches the GUI application.

### Behavior
- **macOS**: Creates a Java thread using a `Runnable` proxy and starts the macOS event loop using `PyObjCTools.AppHelper.runConsoleEventLoop()`.
- **Other Platforms (Linux, Windows)**: Executes the callback function directly.

### Example
```python
from jpype import setupGuiEnvironment
from javafx.application import Platform

def say_hello_later():
    """Test function for scheduling a task on the JavaFX Application Thread."""
    print("Hello from JavaFX!")

def launch_gui():
    """Launch the GUI application."""
    # Example: Schedule a task on the JavaFX Application Thread
    Platform.runLater(say_hello_later)
    print("GUI launched")

# Use setupGuiEnvironment to ensure cross-platform compatibility
setupGuiEnvironment(launch_gui)
```

### Notes
- Recommended for Swing and JavaFX applications to avoid threading issues such as race conditions or improper GUI updates.
```

--------------------------------

### Passing a Python function to a Java method

Source: https://jpype.readthedocs.io/en/latest/userguide.html

Python script that starts the JVM, imports the Java Example class, and passes a Python function to the Java method applyFunction.

```python
import jpype import jpype.imports
jpype.startJVM()

from java.util.function import Function from Example import Example

# Define a Python function
def to_uppercase(s):
    return s.upper()

# Pass the Python function to the Java method
result = Example.applyFunction(to_uppercase, "hello")
print(result)  #Output: HELLO

```

--------------------------------

### Start JVM with classpath and options

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Initializes the JVM with a classpath list and JVM options. The classpath argument accepts paths to JAR files or directories, and jvmOptions can include flags like -ea to enable assertions.

```python
import jpype

# Start the JVM with classpath and options
jpype.startJVM(
    classpath=['lib/*', 'classes'],
    jvmOptions=["-ea"]  # Enable assertions
)
```

--------------------------------

### Passing a Python function to a Java functional interface

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Starts the JVM, imports the Java Function and Example classes, defines a Python function, and passes it to Example.applyFunction. The result is printed as HELLO.

```python
import jpype import jpype.imports
jpype.startJVM()

from java.util.function import Function from Example import Example

# Define a Python function
def to_uppercase(s):
    return s.upper()

# Pass the Python function to the Java method
result = Example.applyFunction(to_uppercase, "hello")
print(result)  #Output: HELLO
```

--------------------------------

### Java example classes (BaseClass and MyClass)

Source: https://jpype.readthedocs.io/en/latest/_sources/quickguide.rst.txt

Defines the Java classes used throughout the guide. BaseClass has a callMember method; MyClass extends it and includes static fields, constructors, overloaded methods, and a method that throws an exception.

```java
package org.pkg;

public class BaseClass
{
   public void callMember(int i)
   {}
}

public class MyClass extends BaseClass
{
   final public static int CONST_FIELD = 1;
   public static int staticField = 1;
   public int memberField = 2;
   int internalField =3;

   public MyClass() {}
   public MyClass(int i) {}

   public static void callStatic(int i) {}
   public void callMember(int i) {}

   // Python name conflict
   public void pass() {}

   public void throwsException() throws java.lang.Exception {}

   // Overloaded methods
   public void call(int i) {}
   public void call(double d) {}
}
```

--------------------------------

### Enable coverage instrumentation with setup.py develop

Source: https://jpype.readthedocs.io/en/latest/develguide.html

Run this command to enable coverage instrumentation for JPype tests. Requires the 'enable-coverage' option.

```bash
python setup.py develop --enable-coverage

```

--------------------------------

### Attach and detach Java threads with JPype

Source: https://jpype.readthedocs.io/en/latest/userguide.html

Example showing how to use java.lang.Thread.attach(), java.lang.Thread.detach(), and java.lang.Thread.attachAsDaemon() to manage thread attachment to the JVM. It starts the JVM, attaches the current thread as a user thread, detaches it, and then attaches as a daemon thread.

```python
import jpype
import jpype.imports

jpype.startJVM()

# Attach the thread as a user thread
java.lang.Thread.attach()
print("Thread attached as a user thread.")

# Perform Java operations here...

# Detach the thread after completing Java operations
java.lang.Thread.detach()
print("Thread detached from the JVM.")

# Attach the thread as a daemon thread
java.lang.Thread.attachAsDaemon()
print("Thread attached as a daemon thread.")

```

--------------------------------

### Python translation using JPype

Source: https://jpype.readthedocs.io/en/latest/userguide.html

Python code that uses JPype to start the JVM with the customer's jar file, import the Java module, and replicate the Java example's logic. This is the ported version of the Java code.

```python
# Boiler plate stuff to start the module
import jpype
import jpype.imports
from jpype.types import *

# Launch the JVM
jpype.startJVM(classpath=['jars/database.jar'])

# import the Java modules
from com.paying.customer import DataBase

# Copy in the patterns from the guide to replace the example code
db = Database("our_records")
with db.connect() as c:
    c.runQuery()
    while c.hasRecords():
        record = db.nextRecord()
        ...

```

--------------------------------

### Define Java classes used in JPype examples

Source: https://jpype.readthedocs.io/en/latest/quickguide.html

Java class definitions for BaseClass and MyClass used throughout the guide. MyClass includes static and instance fields, constructors, methods, an overloaded method, and a method that throws an exception.

```java
package org.pkg;

public class BaseClass
{
   public void callMember(int i)
   {}
}

public class MyClass extends BaseClass
{
   final public static int CONST_FIELD = 1;
   public static int staticField = 1;
   public int memberField = 2;
   int internalField =3;

   public MyClass() {}
   public MyClass(int i) {}

   public static void callStatic(int i) {}
   public void callMember(int i) {}

   // Python name conflict
   public void pass() {}

   public void throwsException() throws java.lang.Exception {}

   // Overloaded methods
   public void call(int i) {}
   public void call(double d) {}
}

```

--------------------------------

### Start JVM with classpath

Source: https://jpype.readthedocs.io/en/latest/_sources/quickguide.rst.txt

Launches the JVM with a classpath that includes all jars in the 'jars' directory. Use this before any Java calls.

```python
# Launch the JVM
jpype.startJVM(classpath = ['jars/*'])
```

--------------------------------

### Create a Java string (Java)

Source: https://jpype.readthedocs.io/en/latest/_sources/quickguide.rst.txt

Java example showing how to create a Java String object.

```java
String javaStr = new String("foo");
```

--------------------------------

### Disable faulthandler after module enables it

Source: https://jpype.readthedocs.io/en/latest/userguide.html

Insert this call to disable the faulthandler after a module such as absl has enabled it, to prevent potential crashes. For example, absl installs faulthandlers in app.run, so the first call to the main routine would need to disable faulthandlers.

```python
import faulthandler
faulthandler.disable()

```

--------------------------------

### Java example: MyExample class using Database

Source: https://jpype.readthedocs.io/en/latest/userguide.html

Original Java code provided by the customer. It creates a Database connection, runs a query, and iterates over records. This is the code to be ported to Python.

```java
package com.paying.customer;

import com.paying.customer.DataBase

public class MyExample {
   public void main(String[] args) {
     Database db = new Database("our_records");
     try (DatabaseConnection c = db.connect())
     {
        c.runQuery();
        while (c.hasRecords())
        {
          Record record = db.nextRecord();
          ...
        }
     }
  }
}

```

--------------------------------

### Database Access with jpype.dbapi2

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Connects to a Java-based database using the Python Database API (PEP 249) via JDBC. Requires starting the JVM with the JDBC driver in the classpath. The example shows connecting, querying, fetching results, and closing resources.

```python
import jpype
import jpype.dbapi2 as dbapi2

# Start the JVM with the JDBC driver
jpype.startJVM(classpath=["path/to/jdbc/driver.jar"])

# Connect to the database
connection = dbapi2.connect(
    "jdbc:database_url",  # JDBC URL for the database
    {"user": "username", "password": "password"}  # Connection properties
)

# Create a cursor and execute a query
cursor = connection.cursor()
cursor.execute("SELECT * FROM my_table")

# Fetch and process results
results = cursor.fetchall()
for row in results:
    print(row)

# Close the cursor and connection
cursor.close()
connection.close()

# Shut down the JVM
jpype.shutdownJVM()
```

--------------------------------

### Combine Java Streams and Python List Comprehensions

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Use the Java Stream API to filter a list and then apply a Pythonic list comprehension for further processing. The example filters a Java list for items starting with 'a', collects them to a list, then converts each item to lowercase, printing ['apple'].

```python
# Use Java Stream API for filtering
filtered_stream = jlist.stream().filter(lambda s: s.startswith("a")).collect(
    Collectors.toList())

# Use Pythonic list comprehension for further processing
final_result = [item.lower() for item in filtered_stream]
print(final_result)  # Output: ['apple']
```

--------------------------------

### Start JVM with JDK documentation zip for Javadoc

Source: https://jpype.readthedocs.io/en/latest/_sources/userguide.rst.txt

Starts the JVM with the JDK documentation zip on the classpath to enable Javadoc extraction for java.lang classes. Use this before calling help() on Java classes or methods.

```java
import jpype
jpype.startJVM(classpath='jdk-11.0.7_doc-all.zip')
```
Tokens:
Raw