Merge branch 'LeeKamentsky:master' into master

bethac07 · web-flow · commit 79c1a9169d74 · 2024-09-02T08:02:49.000-04:00
diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml
@@ -27,5 +27,5 @@ jobs:
         TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
         TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
       run: |
-        python setup.py sdist bdist_wheel
-        twine upload dist/*
+        python -m build
+        pip install dist/*.whl
diff --git a/_javabridge.pyx b/_javabridge.pyx
@@ -1082,35 +1082,35 @@ cdef class JB_Env:
             result = unichr(cresult)
         elif sig == 'S':
             with nogil:
-                sresult = jnienv[0].CallShortMethodA(jnienv, klass, m_id, values)
+                sresult = jnienv[0].CallStaticShortMethodA(jnienv, klass, m_id, values)
             result = sresult
         elif sig == 'I':
             with nogil:
-                iresult = jnienv[0].CallIntMethodA(jnienv, klass, m_id, values)
+                iresult = jnienv[0].CallStaticIntMethodA(jnienv, klass, m_id, values)
             result = iresult
         elif sig == 'J':
             with nogil:
-                jresult = jnienv[0].CallLongMethodA(jnienv, klass, m_id, values)
+                jresult = jnienv[0].CallStaticLongMethodA(jnienv, klass, m_id, values)
             result = jresult
         elif sig == 'F':
             with nogil:
-                fresult = jnienv[0].CallFloatMethodA(jnienv, klass, m_id, values)
+                fresult = jnienv[0].CallStaticFloatMethodA(jnienv, klass, m_id, values)
             result = fresult
         elif sig == 'D':
             with nogil:
-                dresult = jnienv[0].CallDoubleMethodA(jnienv, klass, m_id, values)
+                dresult = jnienv[0].CallStaticDoubleMethodA(jnienv, klass, m_id, values)
             result = dresult
         elif sig[0] == 'L' or sig[0] == '[':
             with nogil:
-                oresult = jnienv[0].CallObjectMethodA(jnienv, klass, m_id, values)
+                oresult = jnienv[0].CallStaticObjectMethodA(jnienv, klass, m_id, values)
             if oresult == NULL:
                 result = None
             else:
                 result, e = make_jb_object(self, oresult)
                 if e is not None:
                     raise e
         elif sig == 'V':
-            self.env[0].CallVoidMethodA(self.env, c.c, m.id, values)
+            self.env[0].CallStaticVoidMethodA(self.env, c.c, m.id, values)
             result = None
         else:
             free(<void *>values)
diff --git a/_javabridge_mac.pyx b/_javabridge_mac.pyx
@@ -31,11 +31,11 @@ cdef extern from "mac_javabridge_utils.h":
     int MacIsMainThread() nogil
     void MacRunLoopRunInMode(double) nogil
 
-cdef void StopVM(JavaVM *vm):
+cdef void StopVM(JavaVM *vm) noexcept:
      MacStopVM()
 
 #
 # Unused stub in Mac
 #
-cdef int CreateJavaVM(JavaVM **pvm, void **pEnv, void *args):
+cdef int CreateJavaVM(JavaVM **pvm, void **pEnv, void *args) noexcept:
     return -1
diff --git a/_javabridge_nomac.pyx b/_javabridge_nomac.pyx
@@ -9,37 +9,37 @@ cdef extern from "jni.h":
     ctypedef JNIInvokeInterface_ *JavaVM
 
     ctypedef struct JNIInvokeInterface_:
-         jint (*DestroyJavaVM)(JavaVM *vm) nogil
-         jint (*AttachCurrentThread)(JavaVM *vm, void **penv, void *args) nogil
-         jint (*DetachCurrentThread)(JavaVM *vm) nogil
-         jint (*GetEnv)(JavaVM *vm, void **penv, jint version) nogil
-         jint (*AttachCurrentThreadAsDaemon)(JavaVM *vm, void *penv, void *args) nogil
-    jint JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args) nogil
-
-cdef int MacStartVM(JavaVM **pvm, JavaVMInitArgs *pVMArgs, char *class_name) nogil:
+         jint (*DestroyJavaVM)(JavaVM *vm) noexcept nogil
+         jint (*AttachCurrentThread)(JavaVM *vm, void **penv, void *args) noexcept nogil
+         jint (*DetachCurrentThread)(JavaVM *vm) noexcept nogil
+         jint (*GetEnv)(JavaVM *vm, void **penv, jint version) noexcept nogil
+         jint (*AttachCurrentThreadAsDaemon)(JavaVM *vm, void *penv, void *args) noexcept nogil
+    jint JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args) noexcept nogil
+
+cdef int MacStartVM(JavaVM **pvm, JavaVMInitArgs *pVMArgs, char *class_name) noexcept nogil:
     return -1
 
-cdef void StopVM(JavaVM *vm) nogil:
+cdef void StopVM(JavaVM *vm) noexcept nogil:
     vm[0].DestroyJavaVM(vm)
 
-cdef void MacRunLoopInit() nogil:
+cdef void MacRunLoopInit() noexcept nogil:
     pass
 
-cdef void MacRunLoopRun() nogil:
+cdef void MacRunLoopRun() noexcept nogil:
     pass
 
-cdef void MacRunLoopStop() nogil:
+cdef void MacRunLoopStop() noexcept nogil:
     pass
 
-cdef void MacRunLoopReset() nogil:
+cdef void MacRunLoopReset() noexcept nogil:
     pass
 
-cdef int MacIsMainThread() nogil:
+cdef int MacIsMainThread() noexcept nogil:
     return 0
 
-cdef void MacRunLoopRunInMode(double timeout) nogil:
+cdef void MacRunLoopRunInMode(double timeout) noexcept nogil:
     pass
 
-cdef int CreateJavaVM(JavaVM **pvm, void **pEnv, void *args) nogil:
+cdef int CreateJavaVM(JavaVM **pvm, void **pEnv, void *args) noexcept nogil:
     return JNI_CreateJavaVM(pvm, pEnv, args)
 
diff --git a/javabridge/locate.py b/javabridge/locate.py
@@ -133,7 +133,17 @@ def get_out(cmd):
         java_dir = get_out(["readlink", "-f", java_bin])
         java_version_string = get_out(["bash", "-c", "java -version"])
         if re.search('^openjdk', java_version_string, re.MULTILINE) is not None:
-            jdk_dir = os.path.join(java_dir, "..", "..", "..")
+            pattern = 'openjdk version "([^"]+)"'
+            match = re.search(pattern, java_version_string, re.MULTILINE)
+            if match:
+                version = match.groups()[0]
+                if version < "1.8":
+                    jdk_dir = os.path.join(java_dir, "..", "..", "..")
+                else:
+                    jdk_dir = os.path.join(java_dir, "..", "..")
+            else:
+                raise RuntimeError("Failed to parse version from %s" % 
+                                   java_version_string)
         elif re.search('^java', java_version_string, re.MULTILINE) is not None:
             jdk_dir = os.path.join(java_dir, "..", "..")
         else:
diff --git a/javabridge/tests/test_jutil.py b/javabridge/tests/test_jutil.py
@@ -620,7 +620,7 @@ def test_11_01_make_run_dictionary(self):
             "baz", a)
         d = make_run_dictionary(o)
         self.assertIn("foo", d)
-        self.assertEquals(d["foo"], "bar")
+        self.assertEqual(d["foo"], "bar")
         self.assertIn("baz", d)
         self.assertTrue(javabridge.call(d["baz"], "equals", 
                                         "(Ljava/lang/Object;)Z", a))
diff --git a/javabridge/tests/test_wrappers.py b/javabridge/tests/test_wrappers.py
@@ -15,18 +15,18 @@ class TestJWrapper(unittest.TestCase):
     def test_01_01_init(self):
         jobj = J.get_env().new_string(u"Hello, world.")
         obj = J.JWrapper(jobj)
-        self.assertEquals(jobj, obj.o)
+        self.assertEqual(jobj, obj.o)
 
     def test_01_02_call_noargs(self):
         jobj = J.get_env().new_string(u"Hello, world.")
         obj = J.JWrapper(jobj)
-        self.assertEquals(obj.toLowerCase(), "hello, world.")
+        self.assertEqual(obj.toLowerCase(), "hello, world.")
 
     def test_01_03_call_args(self):
         jobj = J.get_env().new_string(u"Hello, world.")
         obj = J.JWrapper(jobj)
         result = obj.replace("Hello,", "Goodbye cruel")
-        self.assertEquals(result, "Goodbye cruel world.")
+        self.assertEqual(result, "Goodbye cruel world.")
 
     def test_01_04_call_varargs(self):
         sclass = J.JWrapper(J.class_for_name("java.lang.String"));
@@ -41,52 +41,52 @@ def test_01_04_call_varargs(self):
     def test_02_01_get_field(self):
         obj = J.JClassWrapper("org.cellprofiler.javabridge.test.RealRect")(
             1.5, 2.5, 3.5, 4.5)
-        self.assertEquals(obj.x, 1.5)
+        self.assertEqual(obj.x, 1.5)
 
     def test_02_02_set_field(self):
         obj = J.JClassWrapper("org.cellprofiler.javabridge.test.RealRect")(
             1.5, 2.5, 3.5, 4.5)
         obj.x = 2.5
-        self.assertEquals(obj.x, 2.5)
+        self.assertEqual(obj.x, 2.5)
 
 class TestJClassWrapper_Unboxing(unittest.TestCase):
     def setUp(self):
         self.i = J.JClassWrapper('java.lang.Integer')(3)
 
     def test_01_01_int(self):
-        self.assertEquals(int(self.i), 3)
+        self.assertEqual(int(self.i), 3)
     
     def test_01_02_float(self):
-        self.assertEquals(float(self.i),3.0)
+        self.assertEqual(float(self.i),3.0)
     
     def test_01_03_str(self):
-        self.assertEquals(str(self.i), '3')
+        self.assertEqual(str(self.i), '3')
 
 class TestJClassWrapper_Collection(unittest.TestCase):
     def setUp(self):
         self.a = J.JClassWrapper('java.util.ArrayList')()
-        self.assertEquals(len(self.a), 0)
+        self.assertEqual(len(self.a), 0)
         self.ints = [0,1,2,4,8,16]
-        self.assertEquals(len(self.ints), 6)
+        self.assertEqual(len(self.ints), 6)
         for i in self.ints:
             self.a.add(i)
 
     def test_01_01_get_len(self):
-        self.assertEquals(len(self.a), len(self.ints))
+        self.assertEqual(len(self.a), len(self.ints))
 
     def test_01_02_iterate(self):
         for x,y in zip(self.a, self.ints):
-            self.assertEquals(x.intValue(), y)
+            self.assertEqual(x.intValue(), y)
 
     def test_01_03_get_index(self):
         for i in range(len(self.a)):
-            self.assertEquals(self.a[i].intValue(), self.ints[i])
+            self.assertEqual(self.a[i].intValue(), self.ints[i])
 
     def test_01_04_set_index(self):
         for i in range(len(self.a)):
             self.a[i] = 10
         for i in range(len(self.a)):
-            self.assertEquals(self.a[i].intValue(), 10)
+            self.assertEqual(self.a[i].intValue(), 10)
 
 class TestJClassWrapper(unittest.TestCase):
     def test_01_01_init(self):
@@ -95,21 +95,21 @@ def test_01_01_init(self):
     def test_01_02_field(self):
         c = J.JClassWrapper("java.lang.Short")
         field = c.MAX_VALUE
-        self.assertEquals(field, (1 << 15)-1)
+        self.assertEqual(field, (1 << 15)-1)
 
     def test_02_03_static_call(self):
         c = J.JClassWrapper("java.lang.Integer")
-        self.assertEquals(c.toString(123), "123")
+        self.assertEqual(c.toString(123), "123")
 
     def test_02_04_static_call_varargs(self):
         #
         # Test calling a static function with a variable number of
         # arguments.
         #
         c = J.JClassWrapper("java.lang.String")
-        self.assertEquals(c.format("Hello, %s.", "world"),
+        self.assertEqual(c.format("Hello, %s.", "world"),
                                    "Hello, world.")
-        self.assertEquals(c.format("Goodbye %s %s.", "cruel", "world"),
+        self.assertEqual(c.format("Goodbye %s %s.", "cruel", "world"),
                           "Goodbye cruel world.")
 
     def test_02_05_constructor_varargs(self):
@@ -163,7 +163,7 @@ def call():
             return "foo"
         proxy = J.JProxy('java.util.concurrent.Callable',
                          dict(call = call))
-        self.assertEquals(J.JWrapper(proxy.o).call(), "foo")
+        self.assertEqual(J.JWrapper(proxy.o).call(), "foo")
 
 if __name__=="__main__":
     import javabridge

Original file line number	Diff line number	Diff line change
`@@ -31,11 +31,11 @@ cdef extern from "mac_javabridge_utils.h":`
`31`	`31`	`int MacIsMainThread() nogil`
`32`	`32`	`void MacRunLoopRunInMode(double) nogil`
`33`	`33`
`34`		`-cdef void StopVM(JavaVM *vm):`
	`34`	`+cdef void StopVM(JavaVM *vm) noexcept:`
`35`	`35`	`MacStopVM()`
`36`	`36`
`37`	`37`	`#`
`38`	`38`	`# Unused stub in Mac`
`39`	`39`	`#`
`40`		`-cdef int CreateJavaVM(JavaVM pvm, void pEnv, void *args):`
	`40`	`+cdef int CreateJavaVM(JavaVM pvm, void pEnv, void *args) noexcept:`
`41`	`41`	`return -1`