scyjava 1.10.2__tar.gz → 1.12.0__tar.gz

{scyjava-1.10.2/src/scyjava.egg-info → scyjava-1.12.0}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: scyjava
-Version: 1.10.2
+Version: 1.12.0
 Summary: Supercharged Java access from Python
 Author-email: SciJava developers <ctrueden@wisc.edu>
-License: The Unlicense
+License-Expression: Unlicense
 Project-URL: homepage, https://github.com/scijava/scyjava
 Project-URL: documentation, https://github.com/scijava/scyjava/blob/main/README.md
 Project-URL: source, https://github.com/scijava/scyjava
@@ -15,12 +15,11 @@ Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
 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: License :: OSI Approved :: The Unlicense (Unlicense)
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
@@ -28,10 +27,11 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development :: Libraries :: Java Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: jpype1>=1.3.0
 Requires-Dist: jgo
+Requires-Dist: cjdk
 Provides-Extra: dev
 Requires-Dist: assertpy; extra == "dev"
 Requires-Dist: build; extra == "dev"
@@ -181,7 +181,7 @@ AttributeError: 'list' object has no attribute 'stream'
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 TypeError: No matching overloads found for java.util.Set.addAll(set), options are:
-	public abstract boolean java.util.Set.addAll(java.util.Collection)
+        public abstract boolean java.util.Set.addAll(java.util.Collection)
 >>> from scyjava import to_java as p2j
 >>> jset.addAll(p2j(pset))
 True
@@ -262,6 +262,22 @@ FUNCTIONS
     is_jarray(data: Any) -> bool
         Return whether the given data object is a Java array.
 
+    is_jboolean(the_type: type) -> bool
+
+    is_jbyte(the_type: type) -> bool
+
+    is_jcharacter(the_type: type) -> bool
+
+    is_jdouble(the_type: type) -> bool
+
+    is_jfloat(the_type: type) -> bool
+
+    is_jinteger(the_type: type) -> bool
+
+    is_jlong(the_type: type) -> bool
+
+    is_jshort(the_type: type) -> bool
+
     is_jvm_headless() -> bool
         Return true iff Java is running in headless mode.
 
@@ -313,6 +329,12 @@ FUNCTIONS
         You can pass a single integer to make a 1-dimensional array of that length.
         :return: The newly allocated array
 
+    jsource(data)
+        Try to find the source code using SciJava's SourceFinder.
+        :param data:
+            The object or class or fully qualified class name to check for source code.
+        :return: The URL of the java class
+
     jclass(data)
         Obtain a Java class object.
 
@@ -349,6 +371,14 @@ FUNCTIONS
         :param jtype: The Java type, as either a jimported class or as a string.
         :return: True iff the object is an instance of that Java type.
 
+    jreflect(data, aspect: str = "all") -> List[Dict[str, Any]]
+        Use Java reflection to introspect the given Java object,
+        returning a table of its available methods or fields.
+
+        :param data: The object or class or fully qualified class name to inspect.
+        :param aspect: One of: "all", "constructors", "fields", or "methods".
+        :return: List of dicts with keys: "name", "mods", "arguments", and "returns".
+
     jstacktrace(exc) -> str
         Extract the Java-side stack trace from a Java exception.
 

{scyjava-1.10.2 → scyjava-1.12.0}/README.md

@@ -135,7 +135,7 @@ AttributeError: 'list' object has no attribute 'stream'
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 TypeError: No matching overloads found for java.util.Set.addAll(set), options are:
-	public abstract boolean java.util.Set.addAll(java.util.Collection)
+        public abstract boolean java.util.Set.addAll(java.util.Collection)
 >>> from scyjava import to_java as p2j
 >>> jset.addAll(p2j(pset))
 True
@@ -216,6 +216,22 @@ FUNCTIONS
     is_jarray(data: Any) -> bool
         Return whether the given data object is a Java array.
 
+    is_jboolean(the_type: type) -> bool
+
+    is_jbyte(the_type: type) -> bool
+
+    is_jcharacter(the_type: type) -> bool
+
+    is_jdouble(the_type: type) -> bool
+
+    is_jfloat(the_type: type) -> bool
+
+    is_jinteger(the_type: type) -> bool
+
+    is_jlong(the_type: type) -> bool
+
+    is_jshort(the_type: type) -> bool
+
     is_jvm_headless() -> bool
         Return true iff Java is running in headless mode.
 
@@ -267,6 +283,12 @@ FUNCTIONS
         You can pass a single integer to make a 1-dimensional array of that length.
         :return: The newly allocated array
 
+    jsource(data)
+        Try to find the source code using SciJava's SourceFinder.
+        :param data:
+            The object or class or fully qualified class name to check for source code.
+        :return: The URL of the java class
+
     jclass(data)
         Obtain a Java class object.
 
@@ -303,6 +325,14 @@ FUNCTIONS
         :param jtype: The Java type, as either a jimported class or as a string.
         :return: True iff the object is an instance of that Java type.
 
+    jreflect(data, aspect: str = "all") -> List[Dict[str, Any]]
+        Use Java reflection to introspect the given Java object,
+        returning a table of its available methods or fields.
+
+        :param data: The object or class or fully qualified class name to inspect.
+        :param aspect: One of: "all", "constructors", "fields", or "methods".
+        :return: List of dicts with keys: "name", "mods", "arguments", and "returns".
+
     jstacktrace(exc) -> str
         Extract the Java-side stack trace from a Java exception.
 

{scyjava-1.10.2 → scyjava-1.12.0}/bin/test.sh

@@ -73,7 +73,12 @@ then
 else
   argString=""
 fi
-if [ "$(uname -s)" = "Darwin" ]
+if ! java -version 2>&1 | grep -q '^openjdk version "\(1\.8\|9\|10\|11\|12\|13\|14\|15\|16\)\.'
+then
+  echo "Skipping jep tests due to unsupported Java version:"
+  java -version || true
+  jepCode=0
+elif [ "$(uname -s)" = "Darwin" ]
 then
   echo "Skipping jep tests on macOS due to flakiness"
   jepCode=0

{scyjava-1.10.2 → scyjava-1.12.0}/dev-environment.yml

@@ -12,17 +12,17 @@
 #
 # In addition to the dependencies needed for using scyjava, it
 # includes tools for developer-related actions like running
-# automated tests (pytest) and linting the code (black). If you
+# automated tests (pytest) and linting the code (ruff). If you
 # want an environment without these tools, use environment.yml.
 name: scyjava-dev
 channels:
   - conda-forge
 dependencies:
-  - python >= 3.8
+  - python = 3.9
   # Project dependencies
   - jpype1 >= 1.3.0
   - jgo
-  - openjdk >= 8, < 12
+  - cjdk
   # Test dependencies
   - numpy
   - pandas

{scyjava-1.10.2 → scyjava-1.12.0}/environment.yml

@@ -12,18 +12,18 @@
 #
 # It includes the dependencies needed for using scyjava, but not tools
 # for developer-related actions like running automated tests (pytest),
-# linting the code (black), and generating the API documentation (sphinx).
+# linting the code (ruff), and generating the API documentation (sphinx).
 # If you want an environment including these tools, use dev-environment.yml.
 
 name: scyjava
 channels:
   - conda-forge
 dependencies:
-  - python >= 3.8
+  - python >= 3.9
   # Project dependencies
   - jpype1 >= 1.3.0
   - jgo
-  - openjdk >= 8
+  - cjdk
   # Project from source
   - pip
   - pip:

{scyjava-1.10.2 → scyjava-1.12.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [build-system]
-requires = ["setuptools>=61.2"]
+requires = ["setuptools>=77.0.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "scyjava"
-version = "1.10.2"
+version = "1.12.0"
 description = "Supercharged Java access from Python"
-license = {text = "The Unlicense"}
+license = "Unlicense"
 authors = [{name = "SciJava developers", email = "ctrueden@wisc.edu"}]
 readme = "README.md"
 keywords = ["java", "maven", "cross-language"]
@@ -16,12 +16,11 @@ classifiers = [
     "Intended Audience :: Education",
     "Intended Audience :: Science/Research",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
-    "License :: OSI Approved :: The Unlicense (Unlicense)",
+    "Programming Language :: Python :: 3.13",
     "Operating System :: Microsoft :: Windows",
     "Operating System :: Unix",
     "Operating System :: MacOS",
@@ -32,10 +31,11 @@ classifiers = [
 ]
 
 # NB: Keep this in sync with environment.yml AND dev-environment.yml!
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 dependencies = [
     "jpype1 >= 1.3.0",
     "jgo",
+    "cjdk",
 ]
 
 [project.optional-dependencies]

{scyjava-1.10.2 → scyjava-1.12.0}/src/scyjava/__init__.py

@@ -40,6 +40,22 @@ Use Maven artifacts from remote repositories:
     +++oo*OO######O**oo+++++oo*OO######O**oo+++++oo*OO######O**oo+++
     +++oo*OO######OO*oo+++++oo*OO######OO*oo+++++oo*OO######OO*oo+++
 
+Bootstrap a Java installation:
+
+    >>> from scyjava import config, jimport
+    >>> config.set_java_constraints(fetch=True, vendor='zulu', version='17')
+    >>> System = jimport('java.lang.System')
+    cjdk: Installing JDK zulu:17.0.15 to /home/chuckles/.cache/cjdk
+    Download 100% of 189.4 MiB |##########| Elapsed Time: 0:00:02 Time:  0:00:02
+    Extract | |                 #                    | 714 Elapsed Time: 0:00:01
+    cjdk: Installing Maven to /home/chuckles/.cache/cjdk
+    Download 100% of   8.7 MiB |##########| Elapsed Time: 0:00:00 Time:  0:00:00
+    Extract | |#                                     | 102 Elapsed Time: 0:00:00
+    >>> System.getProperty('java.vendor')
+    'Azul Systems, Inc.'
+    >>> System.getProperty('java.version')
+    '17.0.15'
+
 Convert Java collections to Python:
 
     >>> from scyjava import jimport
@@ -71,6 +87,7 @@ import logging
 from functools import lru_cache
 from typing import Any, Callable, Dict
 
+from . import config, inspect
 from ._arrays import is_arraylike, is_memoryarraylike, is_xarraylike
 from ._convert import (
     Converter,
@@ -91,6 +108,10 @@ from ._convert import (
     to_java,
     to_python,
 )
+from ._introspect import (
+    jreflect,
+    jsource,
+)
 from ._jvm import (  # noqa: F401
     available_processors,
     gc,
@@ -111,6 +132,14 @@ from ._script import enable_python_scripting
 from ._types import (
     JavaClasses,
     is_jarray,
+    is_jboolean,
+    is_jbyte,
+    is_jcharacter,
+    is_jdouble,
+    is_jfloat,
+    is_jinteger,
+    is_jlong,
+    is_jshort,
     isjava,
     jarray,
     jclass,

scyjava-1.12.0/src/scyjava/_cjdk_fetch.py

@@ -0,0 +1,121 @@
+"""
+Utility functions for fetching JDK/JRE and Maven.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import subprocess
+from typing import TYPE_CHECKING, Union
+
+import cjdk
+import jpype
+
+import scyjava.config
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+_logger = logging.getLogger(__name__)
+
+
+def ensure_jvm_available() -> None:
+    """Ensure that the JVM is available and Maven is installed."""
+    fetch = scyjava.config.get_fetch_java()
+    if fetch == "never":
+        # Not allowed to use cjdk.
+        return
+    if fetch == "always" or not is_jvm_available():
+        cjdk_fetch_java()
+    if fetch == "always" or not shutil.which("mvn"):
+        cjdk_fetch_maven()
+
+
+def is_jvm_available() -> bool:
+    """Return True if the JVM is available, suppressing stderr on macos."""
+    from unittest.mock import patch
+
+    subprocess_check_output = subprocess.check_output
+
+    def _silent_check_output(*args, **kwargs):
+        # also suppress stderr on calls to subprocess.check_output
+        kwargs.setdefault("stderr", subprocess.DEVNULL)
+        return subprocess_check_output(*args, **kwargs)
+
+    try:
+        with patch.object(subprocess, "check_output", new=_silent_check_output):
+            jpype.getDefaultJVMPath()
+    # on Darwin, may raise a CalledProcessError when invoking `/user/libexec/java_home`
+    except (jpype.JVMNotFoundException, subprocess.CalledProcessError):
+        return False
+    return True
+
+
+def cjdk_fetch_java(vendor: str | None = None, version: str | None = None) -> None:
+    """Fetch java using cjdk and add it to the PATH."""
+    if vendor is None:
+        vendor = scyjava.config.get_java_vendor()
+    if version is None:
+        version = scyjava.config.get_java_version()
+
+    _logger.info(f"Fetching {vendor}:{version} using cjdk...")
+    java_home = cjdk.java_home(vendor=vendor, version=version)
+    _logger.debug(f"java_home -> {java_home}")
+    _add_to_path(str(java_home / "bin"), front=True)
+    os.environ["JAVA_HOME"] = str(java_home)
+
+
+def cjdk_fetch_maven(url: str = "", sha: str = "") -> None:
+    """Fetch Maven using cjdk and add it to the PATH."""
+    # if url was passed as an argument, use it with provided sha
+    # otherwise, use default values for both
+    if not url:
+        url = scyjava.config.get_maven_url()
+        sha = scyjava.config.get_maven_sha()
+
+    # fix urls to have proper prefix for cjdk
+    if url.startswith("http"):
+        if url.endswith(".tar.gz"):
+            url = url.replace("http", "tgz+http")
+        elif url.endswith(".zip"):
+            url = url.replace("http", "zip+http")
+
+    # determine sha type based on length (cjdk requires specifying sha type)
+    # assuming hex-encoded SHA, length should be 40, 64, or 128
+    kwargs = {}
+    if sha_len := len(sha):  # empty sha is fine... we just don't pass it
+        sha_lengths = {40: "sha1", 64: "sha256", 128: "sha512"}
+        if sha_len not in sha_lengths:  # pragma: no cover
+            raise ValueError(
+                "MAVEN_SHA be a valid sha1, sha256, or sha512 hash."
+                f"Got invalid SHA length: {sha_len}. "
+            )
+        kwargs = {sha_lengths[sha_len]: sha}
+
+    _logger.info("Fetching Maven using cjdk...")
+    maven_dir = cjdk.cache_package("Maven", url, **kwargs)
+    _logger.debug(f"maven_dir -> {maven_dir}")
+    if maven_bin := next(maven_dir.rglob("apache-maven-*/**/mvn"), None):
+        _add_to_path(maven_bin.parent, front=True)
+    else:  # pragma: no cover
+        raise RuntimeError(
+            "Failed to find Maven executable on system "
+            "PATH, and download via cjdk failed."
+        )
+
+
+def _add_to_path(path: Union[Path, str], front: bool = False) -> None:
+    """Add a path to the PATH environment variable.
+
+    If front is True, the path is added to the front of the PATH.
+    By default, the path is added to the end of the PATH.
+    If the path is already in the PATH, it is not added again.
+    """
+
+    current_path = os.environ.get("PATH", "")
+    if (path := str(path)) in current_path:
+        return
+    new_path = [path, current_path] if front else [current_path, path]
+    os.environ["PATH"] = os.pathsep.join(new_path)

scyjava-1.12.0/src/scyjava/_introspect.py

@@ -0,0 +1,128 @@
+"""
+Introspection functions for reporting Java
+class methods, fields, and source code URL.
+"""
+
+from typing import Any, Dict, List
+
+from scyjava._jvm import jimport, jvm_version
+from scyjava._types import isjava, jinstance, jclass
+
+
+def jreflect(data, aspect: str = "all") -> List[Dict[str, Any]]:
+    """
+    Use Java reflection to introspect the given Java object,
+    returning a table of its available methods or fields.
+
+    :param data: The object or class or fully qualified class name to inspect.
+    :param aspect: One of: "all", "constructors", "fields", or "methods".
+    :return: List of dicts with keys: "name", "mods", "arguments", and "returns".
+    """
+
+    aspects = ["all", "constructors", "fields", "methods"]
+    if aspect not in aspects:
+        raise ValueError("aspect must be one of {aspects}")
+
+    if not isjava(data) and isinstance(data, str):
+        try:
+            data = jimport(data)
+        except Exception as e:
+            raise ValueError(
+                f"Object of type '{type(data).__name__}' is not a Java object"
+            ) from e
+
+    jcls = data if jinstance(data, "java.lang.Class") else jclass(data)
+
+    Modifier = jimport("java.lang.reflect.Modifier")
+    modifiers = {
+        attr[2:].lower(): getattr(Modifier, attr)
+        for attr in dir(Modifier)
+        if attr.startswith("is")
+    }
+
+    members = []
+    if aspect in ["all", "constructors"]:
+        members.extend(jcls.getConstructors())
+    if aspect in ["all", "fields"]:
+        members.extend(jcls.getFields())
+    if aspect in ["all", "methods"]:
+        members.extend(jcls.getMethods())
+
+    table = []
+
+    for member in members:
+        mtype = str(member.getClass().getName()).split(".")[-1].lower()
+        name = member.getName()
+        modflags = member.getModifiers()
+        mods = [name for name, hasmod in modifiers.items() if hasmod(modflags)]
+        args = (
+            [ptype.getName() for ptype in member.getParameterTypes()]
+            if hasattr(member, "getParameterTypes")
+            else None
+        )
+        returns = (
+            member.getReturnType().getName()
+            if hasattr(member, "getReturnType")
+            else (member.getType().getName() if hasattr(member, "getType") else name)
+        )
+        table.append(
+            {
+                "type": mtype,
+                "name": name,
+                "mods": mods,
+                "arguments": args,
+                "returns": returns,
+            }
+        )
+
+    return table
+
+
+def jsource(data) -> str:
+    """
+    Try to find the source code URL for the given Java object, class, or class name.
+    Requires org.scijava:scijava-search on the classpath.
+    :param data:
+        Object, class, or fully qualified class name for which to discern the source code location.
+    :return: URL of the class's source code.
+    """
+
+    if not isjava(data) and isinstance(data, str):
+        try:
+            data = jimport(data)  # check if data can be imported
+        except Exception as err:
+            raise ValueError(f"Not a Java object {err}")
+    jcls = data if jinstance(data, "java.lang.Class") else jclass(data)
+
+    if jcls.getClassLoader() is None:
+        # Class is from the Java standard library.
+        cls_path = str(jcls.getName()).replace(".", "/")
+
+        # Discern the Java version.
+        jv_digits = jvm_version()
+        assert jv_digits is not None and len(jv_digits) > 1
+        java_version = jv_digits[1] if jv_digits[0] == 1 else jv_digits[0]
+
+        # Note: some classes (e.g. corba and jaxp) will not be located correctly before
+        # Java 10, because they fall under a different subtree than `jdk`. But Java 11+
+        # dispenses with such subtrees in favor of using only the module designations.
+        if java_version <= 7:
+            return f"https://github.com/openjdk/jdk/blob/jdk7-b147/jdk/src/share/classes/{cls_path}.java"
+        elif java_version == 8:
+            return f"https://github.com/openjdk/jdk/blob/jdk8-b120/jdk/src/share/classes/{cls_path}.java"
+        else:  # java_version >= 9
+            module_name = jcls.getModule().getName()
+            # if module_name is null, it's in the unnamed module
+            if java_version == 9:
+                suffix = "%2B181/jdk"
+            elif java_version == 10:
+                suffix = "%2B46"
+            else:
+                suffix = "-ga"
+            return f"https://github.com/openjdk/jdk/blob/jdk-{java_version}{suffix}/src/{module_name}/share/classes/{cls_path}.java"
+
+    # Ask scijava-search for the source location.
+    SourceFinder = jimport("org.scijava.search.SourceFinder")
+    url = SourceFinder.sourceLocation(jcls, None)
+    urlstring = url.toString()
+    return urlstring

{scyjava-1.10.2 → scyjava-1.12.0}/src/scyjava/_jvm.py

@@ -11,6 +11,7 @@ import sys
 from functools import lru_cache
 from importlib import import_module
 from pathlib import Path
+from typing import Sequence
 
 import jpype
 import jpype.config
@@ -18,6 +19,7 @@ from jgo import jgo
 
 import scyjava.config
 from scyjava.config import Mode, mode
+from scyjava._cjdk_fetch import ensure_jvm_available
 
 _logger = logging.getLogger(__name__)
 
@@ -25,16 +27,16 @@ _startup_callbacks = []
 _shutdown_callbacks = []
 
 
-def jvm_version() -> str:
+def jvm_version() -> tuple[int, ...]:
     """
     Gets the version of the JVM as a tuple, with each dot-separated digit
     as one element. Characters in the version string beyond only numbers
     and dots are ignored, in line with the java.version system property.
 
     Examples:
-    * OpenJDK 17.0.1 -> [17, 0, 1]
-    * OpenJDK 11.0.9.1-internal -> [11, 0, 9, 1]
-    * OpenJDK 1.8.0_312 -> [1, 8, 0]
+    * OpenJDK 17.0.1 -> (17, 0, 1)
+    * OpenJDK 11.0.9.1-internal -> (11, 0, 9, 1)
+    * OpenJDK 1.8.0_312 -> (1, 8, 0)
 
     If the JVM is already started, this function returns the equivalent of:
        jimport('java.lang.System')
@@ -55,12 +57,12 @@ def jvm_version() -> str:
 
     assert mode == Mode.JPYPE
 
-    jvm_version = jpype.getJVMVersion()
-    if jvm_version and jvm_version[0]:
+    jvm_ver = jpype.getJVMVersion()
+    if jvm_ver and jvm_ver[0]:
         # JPype already knew the version.
         # JVM is probably already started.
         # Or JPype got smarter since 1.3.0.
-        return jvm_version
+        return jvm_ver
 
     # JPype was clueless, which means the JVM has probably not started yet.
     # Let's look for a java executable, and ask via 'java -version'.
@@ -98,6 +100,7 @@ def jvm_version() -> str:
     except subprocess.CalledProcessError as e:
         raise RuntimeError("System call to java failed") from e
 
+    output = output.replace("\n", " ").replace("\r", "")
     m = re.match('.*version "(([0-9]+\\.)+[0-9]+)', output)
     if not m:
         raise RuntimeError(f"Inscrutable java command output:\n{output}")
@@ -105,7 +108,7 @@ def jvm_version() -> str:
     return tuple(map(int, m.group(1).split(".")))
 
 
-def start_jvm(options=None) -> None:
+def start_jvm(options: Sequence[str] = None) -> None:
     """
     Explicitly connect to the Java virtual machine (JVM). Only one JVM can
     be active; does nothing if the JVM has already been started. Calling
@@ -116,10 +119,12 @@ def start_jvm(options=None) -> None:
     :param options:
         List of options to pass to the JVM.
         For example: ['-Dfoo=bar', '-XX:+UnlockExperimentalVMOptions']
+        See also scyjava.config.add_options.
     """
     # if JVM is already running -- break
     if jvm_started():
-        _logger.debug("The JVM is already running.")
+        if options is not None and len(options) > 0:
+            _logger.debug(f"Options ignored due to already running JVM: {options}")
         return
 
     assert mode == Mode.JPYPE
@@ -131,6 +136,9 @@ def start_jvm(options=None) -> None:
     # use the logger to notify user that endpoints are being added
     _logger.debug("Adding jars from endpoints {0}".format(endpoints))
 
+    # download JDK/JRE and Maven as appropriate
+    ensure_jvm_available()
+
     # get endpoints and add to JPype class path
     if len(endpoints) > 0:
         endpoints = endpoints[:1] + sorted(endpoints[1:])
@@ -179,7 +187,8 @@ def start_jvm(options=None) -> None:
     _logger.debug("Starting JVM")
     if options is None:
         options = scyjava.config.get_options()
-    jpype.startJVM(*options, interrupt=True)
+    kwargs = scyjava.config.get_kwargs()
+    jpype.startJVM(*options, **kwargs)
 
     # replace JPype/JVM shutdown handling with our own
     jpype.config.onexit = False
@@ -225,7 +234,7 @@ def shutdown_jvm() -> None:
         try:
             callback()
         except Exception as e:
-            print(f"Exception during shutdown callback: {e}")
+            _logger.error(f"Exception during shutdown callback: {e}")
 
     # dispose AWT resources if applicable
     if is_awt_initialized():
@@ -237,7 +246,7 @@ def shutdown_jvm() -> None:
     try:
         jpype.shutdownJVM()
     except Exception as e:
-        print(f"Exception during JVM shutdown: {e}")
+        _logger.error(f"Exception during JVM shutdown: {e}")
 
 
 def jvm_started() -> bool: