def verify_bytes(self, jbyte_values, b): arrayB_from_list = jarray(jbyte)(jbyte_values) self.assertEqual(jbyte_values, arrayB_from_list) array_bytes = bytes(arrayB_from_list) self.assertEqual(b, array_bytes) array_bytearray = bytearray(arrayB_from_list) self.assertEqual(b, array_bytearray) arrayB_from_bytes = jarray(jbyte)(b) self.assertEqual(jbyte_values, arrayB_from_bytes) arrayB_from_bytearray = jarray(jbyte)(bytearray(b)) self.assertEqual(jbyte_values, arrayB_from_bytearray)
def test_array(self): Object = jclass("java.lang.Object") Number = jclass("java.lang.Number") self.verify_value(self.obj, "ObjectArray", jarray(Number)([11, 22])) with self.conv_error: # Can't use `context`: exception is raised by `jarray` constructor. self.verify_value(self.obj, "NumberArray", jarray(Object)([False, True])) # Arrays of primitives are not assignable to arrays of Object. self.verify_value(self.obj, "ObjectArray", jarray(jboolean)([False, True]), context=self.conv_error)
def test_conversion(self): Object = jclass("java.lang.Object") Integer = jclass("java.lang.Integer") # All object arrays, primitive arrays, and Python iterables are assignable to Object, # Cloneable and Serializable for array in [jarray(Object)(["hello", 42]), jarray(Integer)([11, 22]), jarray(jboolean)([False, True]), [False, True]]: with self.subTest(array=array): for field in ["object", "cloneable", "serializable"]: with self.subTest(field=field): setattr(TA, field, array) self.assertEqual(array, getattr(TA, field)) with self.assertRaisesRegex(TypeError, "Cannot convert"): setattr(TA, "closeable", array)
def test_set_slice(self): for key, replaced in SLICE_TESTS: with self.subTest(key=key, replaced=replaced): a = jarray(jint)(SLICE_DATA) expected = [99 if x in replaced else x for x in a] a[key] = [99] * len(replaced) self.assertEqual(expected, a) # Length mismatch a = jarray(jint)(SLICE_DATA) for value in [[], [99, 99]]: with self.subTest(value=value), \ self.assertRaisesRegex(ValueError, f"can't set slice of length 1 from value " f"of length {len(value)}"): a[0:1] = value # Arrays of different types. a = jarray(jint)(SLICE_DATA) with self.assertRaisesRegex(TypeError, "Cannot convert float object to int"): a[:2] = jarray(jfloat)([99, 99]) a = jarray(jfloat)(SLICE_DATA) a[:2] = jarray(jint)([99, 99]) self.assertEqual([99, 99, 5, 7, 11], a) # Without optimization, this takes over 200 seconds. The test_get_slice equivalent is # probably faster because Cython compiles the __getitem__ loop into native code, so # leave the array size unchanged in case a future Cython version extends this to more # situations. a = jarray(jint)(500000) b = jarray(jint)(500000) with self.assertTimeLimit(0.5): a[:] = b
def test_add(self): tf = jarray(jboolean)([True, False]) self.assertEqual(tf, tf + []) self.assertEqual(tf, [] + tf) self.assertEqual(tf, tf + jarray(jboolean)([])) self.assertEqual([True, False, True], tf + [True]) with self.assertRaises(TypeError): tf + True with self.assertRaises(TypeError): tf + None String = jclass("java.lang.String") hw = jarray(String)(["hello", "world"]) self.assertEqual([True, False, "hello", "world"], tf + hw)
def test_index(self): a = jarray(jint)([1, 4, 1, 2]) self.assertEqual(0, a.index(1)) self.assertEqual(3, a.index(2)) self.assertEqual(1, a.index(4)) for value in [0, 3, 5]: with self.subTest(value=value): with self.assertRaises(ValueError): a.index(value) empty = jarray(jint)([]) for value in [0, 1]: with self.subTest(value=value): with self.assertRaises(ValueError): empty.index(value)
class Return(static_proxy()): @method(jvoid, []) def void_good(self): pass @method(jvoid, []) def void_bad(self): return "hello" @method(jint, []) def primitive_good(self): return 42 @method(jint, []) def primitive_bad_value(self): return "hello" @method(jint, []) def primitive_bad_null(self): pass @method(String, []) def object_good_value(self): return "hello" @method(String, []) def object_good_null(self): return None @method(String, []) def object_bad(self): return 42 @method(jarray(String), []) def array_good_value(self): return ["hello", "world"] @method(jarray(String), []) def array_good_null(self): return None @method(jarray(String), []) def array_bad_content(self): return [1, 2] @method(jarray(String), []) def array_bad_value(self): return "hello"
def test(path): # x_t = jarray(jdouble)([22.0, 1.0, 0.0, 172.7, 76.7, 2.0, 2.0, 2.0, 2.0, 0.0, 0.0, 2.0, 4.0, 0.0, 0.989, 0.0]) y_t = 3 xx = jarray(jdouble)([5.1,3.5,1.4,0.2]) # 模型加载 clf = joblib.load("storage/data/train_model.m") # 模型预测 # y_prob = clf.predict(x_t, num_iteration=clf.best_iteration) # y_pred = [list(x).index(max(x)) for x in y_prob] # print("预测结果:", y_pred) # score = metrics.accuracy_score(y_pred=y_pred, y_true=y_t) # precision = metrics.precision_score(y_true=y_t, y_pred=y_pred, average=None) # recall = metrics.recall_score(y_true=y_t, y_pred=y_pred, average=None) # matrix = metrics.confusion_matrix(y_true=y_t, y_pred=y_pred) # FAR = [(matrix[1, 0] + matrix[2, 0] + matrix[3, 0]) / ( # matrix[1, 0] + matrix[2, 0] + matrix[3, 0] + matrix[1, 1] + matrix[2, 2] + matrix[3, 3]), # (matrix[0, 1] + matrix[2, 1] + matrix[3, 1]) / ( # matrix[0, 1] + matrix[2, 1] + matrix[3, 1] + matrix[0, 0] + matrix[2, 2] + matrix[3, 3]), # (matrix[1, 2] + matrix[0, 2] + matrix[3, 2]) / ( # matrix[1, 2] + matrix[0, 2] + matrix[3, 2] + matrix[1, 1] + matrix[0, 0] + matrix[3, 3]), # (matrix[1, 3] + matrix[0, 3] + matrix[2, 3]) / ( # matrix[1, 3] + matrix[0, 3] + matrix[2, 3] + matrix[1, 1] + matrix[0, 0] + matrix[2, 2]), # ] # FP/(FP+TN) # print(matrix) # print("AUC score: {:<8.5f}".format(score)) # print('precision' + str(precision)) # print('recall' + str(recall)) # print(" FAR" + str(FAR))
def test_get_int(self): a = jarray(jint)([2, 3, 5, 7, 11]) self.assertEqual(2, a[0]) self.assertEqual(3, a[1]) self.assertEqual(11, a[4]) with self.index_error: a[5] with self.index_error: jarray(jint)([])[0] self.assertEqual(11, a[-1]) self.assertEqual(7, a[-2]) self.assertEqual(2, a[-5]) with self.index_error: a[-6]
def verify(expected, actual): self.assertEqual(expected, actual) self.assertIsInstance( actual, ( unicode if sys.version_info[0] < 3 # noqa: F821 else jarray("Ljava/lang/Object;")))
def test_bytes(self): # Java byte arrays (signed) and Python bytes (unsigned) can be converted both ways. self.verify_bytes([], b"") self.verify_bytes([-128, -127, -2, -1, 0, 1, 126, 127], b"\x80\x81\xFE\xFF\x00\x01\x7E\x7F") # Java primitive arrays (except char[]) can be converted to their raw data bytes. # Expected values are little-endian. for element_type, values, expected in \ [(jboolean, [False, True], b"\x00\x01"), (jbyte, [0, 123], bytes(1) + b"\x7b"), (jshort, [0, 12345], bytes(2) + b"\x39\x30"), (jint, [0, 123456789], bytes(4) + b"\x15\xcd\x5b\x07"), (jlong, [0, 1234567890123456789], bytes(8) + b"\x15\x81\xe9\x7d\xf4\x10\x22\x11"), (jfloat, [0, 1.99], bytes(4) + b"\x52\xb8\xfe\x3f"), (jdouble, [0, 1.99], bytes(8) + b"\xd7\xa3\x70\x3d\x0a\xd7\xff\x3f")]: java_type = jarray(element_type) for python_type in [bytes, bytearray]: with self.subTest(element_type=element_type, python_type=python_type): self.assertEqual(b"", python_type(java_type([]))) self.assertEqual(expected, python_type(java_type(values))) # Integer arrays containing values 0 to 255 can be converted element-wise using `list`. for element_type in [jshort, jint, jlong]: with self.subTest(element_type=element_type): self.assertEqual( b"\x00\x01\x7E\x7F\x80\x81\xFE\xFF", bytes( list( jarray(element_type)( [0, 1, 126, 127, 128, 129, 254, 255])))) # Other array types (including multi-dimensional arrays) will be treated as an iterable # of integers, so converting them to bytes will fail unless the array is empty. for element_type, values in \ [(jchar, "hello"), (jarray(jbyte), [b"hello", b"world"]), (String, ["hello"])]: java_type = jarray(element_type) for python_type in [bytes, bytearray]: with self.subTest(element_type=element_type, python_type=python_type): self.assertEqual(b"", python_type(java_type([]))) with self.assertRaisesRegex( TypeError, "cannot be interpreted as an integer"): python_type(java_type(values))
def test_invalid_index(self): a = jarray(jint)([2, 3, 5, 7, 11]) index_type_error = \ self.assertRaisesRegex(TypeError, "array indices must be integers or slices, not str") with index_type_error: a["hello"] with index_type_error: a["hello"] = 4
def test_set_int(self): a = jarray(jint)([2, 3, 5, 7, 11]) a[0] = 0 a[1] = 10 a[4] = 40 self.assertEqual([0, 10, 5, 7, 40], a) with self.index_error: a[5] = 50 with self.index_error: jarray(jint)([])[0] = 99 a[-1] = -10 a[-2] = -20 a[-5] = -50 self.assertEqual([-50, 10, 5, -20, -10], a) with self.index_error: a[-6] = -60
def test_output_arg(self): string = String('\u1156\u2278\u3390\u44AB') for btarray in ([0] * 4, (0, ) * 4, jarray(jbyte)([0] * 4)): # This version of getBytes returns the 8 low-order of each Unicode character. string.getBytes(0, 4, btarray, 0) if not isinstance(btarray, tuple): self.assertEquals( btarray, [ctypes.c_int8(x).value for x in [0x56, 0x78, 0x90, 0xAB]])
def test_modify(self): Object = jclass("java.lang.Object") array_Z = jarray(jboolean)([True, False]) with self.assertRaisesRegex(TypeError, "Cannot convert int object to boolean"): array_Z[0] = 1 with self.assertRaisesRegex(TypeError, "Cannot convert Object object to boolean"): array_Z[0] = Object() Boolean = jclass("java.lang.Boolean") array_Boolean = jarray(Boolean)([True, False]) with self.assertRaisesRegex(TypeError, "Cannot convert int object to java.lang.Boolean"): array_Boolean[0] = 1 with self.assertRaisesRegex(TypeError, "Cannot convert int object to java.lang.Boolean"): cast(jarray(Object), array_Boolean)[0] = 1 array_Object = jarray(Object)([True, False]) array_Object[0] = 1 self.assertEqual([1, False], array_Object)
def test_eq(self): tf = jarray(jboolean)([True, False]) self.verify_equal(tf, tf) self.verify_equal(tf, jarray(jboolean)([True, False])) self.verify_equal(tf, [True, False]) self.verify_equal(tf, [1, 0]) self.verify_not_equal(tf, [True, True]) self.verify_not_equal(tf, [True, False, True]) single = jarray(jboolean)([True]) self.verify_not_equal(single, True) empty = jarray(jboolean)([]) self.verify_equal(empty, empty) self.verify_equal(empty, []) self.verify_not_equal(empty, single) self.verify_not_equal(empty, False)
def test_basic(self): array_C = jarray(jchar)("hello") self.assertEqual(5, len(array_C)) self.assertEqual(repr(array_C), "jarray('C')(['h', 'e', 'l', 'l', 'o'])") self.assertTrue(isinstance(array_C, jclass("java.lang.Object"))) self.assertTrue(isinstance(array_C, jclass("java.lang.Cloneable"))) self.assertTrue(isinstance(array_C, jclass("java.io.Serializable"))) self.assertFalse(isinstance(array_C, jclass("java.io.Closeable"))) self.assertRegex(array_C.toString(), r"^\[C")
def test_array(self): list_bool = [True, False] for jarray_Z in [jarray(jboolean)(list_bool), jarray("Z")(list_bool)]: self.assertEqual("[Z", type(jarray_Z).__name__) self.assertEqual("jarray('Z')({!r})".format(list_bool), str(jarray_Z)) list_list_bool = [[True, False], [False, True]] jarray_jarray_Z = jarray(jarray(jboolean))(list_list_bool) self.assertEqual("[[Z", type(jarray_jarray_Z).__name__) self.assertEqual("jarray('[Z')({!r})".format(list_list_bool), str(jarray_jarray_Z)) list_str = ["one", "two"] String = jclass("java.lang.String") jarray_String = jarray(String)(list_str) self.assertEqual("[Ljava/lang/String;", type(jarray_String).__name__) self.assertEqual("jarray('Ljava/lang/String;')({!r})".format(list_str), str(jarray_String))
def test_bytes(self): self.verify_bytes([], b"") self.verify_bytes([-128, -127, -2, -1, 0, 1, 2, 126, 127], b"\x80\x81\xFE\xFF\x00\x01\x02\x7E\x7F") # These optional arguments are not part of the public API and are subject to change. array_B = jarray(jbyte)([0, 102, 111, 111, 127, -1, -128]) self.assertEqual(b"\x00foo\x7F\xFF\x80", array_B.__bytes__()) self.assertEqual(b"foo", array_B.__bytes__(1, 3)) self.assertEqual(b"\xFF\x80", array_B.__bytes__(5)) self.assertEqual(b"\x00foo", array_B.__bytes__(length=4))
def test_invalid_index(self): a = jarray(jint)(SLICE_DATA) for index in ["", "hello", 0.0, 1.0]: with self.subTest(index=index): error = self.assertRaisesRegex( TypeError, fr"array indices must be integers or slices, not " fr"{type(index).__name__}") with error: a[index] with error: a[index] = 99 self.assertEqual(SLICE_DATA, a)
def audio_samples(x): # get float data from string array x = x.replace("[", "").replace("]", "") x = x.split(",") x = np.array(x) x = x.astype(np.float) x = x / 32768.0 #Convert to [-1.0, +1.0] # Calculate MFCC features x = waveform_to_examples(x, RATE) return jarray(jfloat)(x.reshape(-1))
def test_blank(self): array_Z = jarray(jboolean)(2) self.assertEqual(2, len(array_Z)) self.assertEqual([False, False], array_Z) array_C = jarray(jchar)(3) self.assertEqual(3, len(array_C)) self.assertEqual([u"\u0000", u"\u0000", u"\u0000"], array_C) array_I = jarray(jint)(2) self.assertEqual(2, len(array_I)) self.assertEqual([0, 0], array_I) from java.lang import Object array_Object = jarray(Object)(3) self.assertEqual(3, len(array_Object)) self.assertEqual([None, None, None], array_Object) array_empty = jarray(Object)(0) self.assertEqual(0, len(array_empty)) self.assertEqual([], array_empty)
def test_jni_sig(self): Object = jclass("java.lang.Object") self.assertEquals("V", jni_sig(jvoid)) self.assertEquals("Z", jni_sig(jboolean)) self.assertEquals("B", jni_sig(jbyte)) self.assertEquals("C", jni_sig(jchar)) self.assertEquals("D", jni_sig(jdouble)) self.assertEquals("F", jni_sig(jfloat)) self.assertEquals("I", jni_sig(jint)) self.assertEquals("J", jni_sig(jlong)) self.assertEquals("S", jni_sig(jshort)) self.assertEquals("Ljava/lang/Object;", jni_sig(Object)) self.assertEquals("[Z", jni_sig(jarray(jboolean))) self.assertEquals("[[Z", jni_sig(jarray(jarray(jboolean)))) self.assertEquals("[Ljava/lang/Object;", jni_sig(jarray(Object))) self.assertEquals("[[Ljava/lang/Object;", jni_sig(jarray(jarray(Object)))) with self.assertRaisesRegex( ValueError, "Invalid JNI signature: 'java.lang.Object'"): jni_sig("java.lang.Object") for obj in [0, True, None, int, str]: with self.subTest(obj=obj): with self.assertRaisesRegex(TypeError, f"{obj!r} is not a Java type"): jni_sig(obj)
def reshape(raw_data, window_size, step_width): ''' input: [n_input,9] n_input = n_sec * frequence 9, data from 3 sensors output: [n_output, window_size, 9] n_output = ''' python_raw_data = java.cast(java.jarray(java.jarray(java.jfloat)), raw_data) raw_data = np.array(python_raw_data) new_feat_count = ((raw_data.shape[0] - window_size) // step_width) + 1 reshaped_feat = np.empty((new_feat_count, window_size, 9)) for idx, window in enumerate( utils_gen_windows(raw_data.shape[0], window_size, step_width) ): new_row = raw_data[window[0] : window[1]] if idx < new_feat_count: reshaped_feat[idx, :] = new_row return reshaped_feat
def test_bytes(self): # Java byte arrays work for values -128 to 127. self.verify_bytes([], b"") self.verify_bytes([-128, -127, -2, -1, 0, 1, 126, 127], b"\x80\x81\xFE\xFF\x00\x01\x7E\x7F") # Other Java array types cannot be directly converted to bytes. for element_type, value in [(jint, 42), (jfloat, 3.0), (jchar, "x"), (String, "hello")]: a = jarray(element_type)([value]) for cls in [bytes, bytearray]: with self.assertRaisesRegexp( TypeError, "__getbuffer__ is not implemented"): cls(a) # But integer array types can be converted indirectly for values 0 to 255. for element_type in [jshort, jint, jlong]: self.assertEqual( b"\x00\x01\x7E\x7F\x80\x81\xFE\xFF", bytes( list( jarray(element_type)( [0, 1, 126, 127, 128, 129, 254, 255]))))
def test_type_jni(self): self.assertIs(jarray(String), jarray("Ljava/lang/String;")) with self.assertRaisesRegex(jclass("java.lang.NoClassDefFoundError"), "java.lang.Nonexistent"): jarray("Ljava/lang/Nonexistent;") with self.assertRaisesRegex(ValueError, "Invalid JNI signature: 'java.lang.String'"): jarray("java.lang.String")
def verify_bytes(self, jbyte_values, b): arrayB_from_list = jarray(jbyte)(jbyte_values) self.assertEqual(jbyte_values, arrayB_from_list) to_bytes = (bytes if sys.version_info[0] >= 3 else lambda x: x.__bytes__()) array_bytes = to_bytes(arrayB_from_list) self.assertIsInstance(array_bytes, bytes) self.assertEqual(b, array_bytes) # TODO #5231: use `bytearray(bytes(...))` instead. # array_bytearray = bytearray(arrayB_from_list) # self.assertEqual(b, array_bytearray) arrayB_from_bytes = jarray(jbyte)(b) self.assertEqual(jbyte_values, arrayB_from_bytes) arrayB_from_bytearray = jarray(jbyte)(bytearray(b)) self.assertEqual(jbyte_values, arrayB_from_bytearray) b_as_ints = b if (sys.version_info[0] >= 3) else map(ord, b) arrayI_from_bytes = jarray(jint)(b_as_ints) self.assertEqual(b_as_ints, arrayI_from_bytes) with self.assertRaisesRegexp( TypeError, "Cannot call __bytes__ on int[], only on byte[]"): to_bytes(arrayI_from_bytes)
def test_identity(self): from java.lang import Object, String Object_klass, String_klass = Object.getClass(), String.getClass() self.assertIsNot(Object_klass, String_klass) self.t.fieldKlass = Object_klass self.assertIs(Object_klass, self.t.fieldKlass) self.t.setKlass(String_klass) self.assertIs(String_klass, self.t.getKlass()) a1, a2 = [jarray(String)(x) for x in [["one", "two"], ["three", "four"]]] self.assertIsNot(a1, a2) self.t.fieldStringArray = a1 self.assertIs(a1, self.t.fieldStringArray) self.t.setStringArray(a2) self.assertIs(a2, self.t.getStringArray())
def test_output_arg(self): string = String('\u1156\u2278\u3390\u44AB') for btarray in ([0] * 4, (0,) * 4, jarray(jbyte)([0] * 4)): # This version of getBytes returns the 8 low-order of each Unicode character. string.getBytes(0, 4, btarray, 0) if not isinstance(btarray, tuple): self.assertEqual(btarray, [ctypes.c_int8(x).value for x in [0x56, 0x78, 0x90, 0xAB]]) for method in ["arraySort", "arraySortObject"]: for input in [[], [42], [5, 7, 2, 11, 3]]: with self.subTest(method=method, input=input): l = input.copy() getattr(TA, method)(l) self.assertEqual(sorted(input), l)
def test_varargs(self): obj = jclass("com.chaquo.python.TestOverload$Varargs")() self.assertEqual("", obj.resolve_empty_single_I()) self.assertEqual("int... []", obj.resolve_empty_single_I([])) self.assertEqual("int... null", obj.resolve_empty_single_I(None)) self.assertEqual("int 1", obj.resolve_empty_single_I(1)) self.assertEqual("int... [1]", obj.resolve_empty_single_I([1])) self.assertEqual("int... [1, 2]", obj.resolve_empty_single_I(1, 2)) self.assertEqual("int... [1, 2]", obj.resolve_empty_single_I([1, 2])) self.assertEqual("int... []", obj.resolve_ID()) # int is more specific than double. with self.ambiguous: obj.resolve_ID(None) # But int[] is not more specific than double[]. self.assertEqual("int... null", obj.resolve_ID(cast(jarray(jint), None))) self.assertEqual("double... null", obj.resolve_ID(cast(jarray(jdouble), None))) with self.inapplicable: obj.resolve_ID(None, None) self.assertEqual("int 42", obj.resolve_ID(42)) self.assertEqual("double 42.0", obj.resolve_ID(42.0)) self.assertEqual("double... [1.0, 2.0]", obj.resolve_ID(jarray(jdouble)([1, 2]))) self.assertEqual("double... [1.0, 2.0]", obj.resolve_ID(1.0, 2.0)) self.assertEqual("double... [1.0, 2.0]", obj.resolve_ID(1, 2.0)) self.assertEqual("double... [1.0, 2.0]", obj.resolve_ID(1.0, 2)) Long = jclass("java.lang.Long") with self.ambiguous: obj.resolve_I_Long() # Neither int nor Long are more specific. with self.ambiguous: obj.resolve_I_Long(None) # Neither int[] nor Long[] are more specific. self.assertEqual("Long... [null, null]", obj.resolve_I_Long(None, None)) with self.ambiguous: obj.resolve_I_Long(42) with self.inapplicable: obj.resolve_I_Long(42.0) self.assertEqual("int... [42]", obj.resolve_I_Long(jint(42))) self.assertEqual("Long... [42]", obj.resolve_I_Long(jlong(42))) self.assertEqual("Long... [42]", obj.resolve_I_Long(Long(42))) Number = jclass("java.lang.Number") # Long[] is more specific than Number[]. self.assertEqual("Long... []", obj.resolve_Number_Long()) self.assertEqual("Long... [42]", obj.resolve_Number_Long(42)) self.assertEqual("Long... null", obj.resolve_Number_Long(None)) self.assertEqual("Long... [null]", obj.resolve_Number_Long([None])) self.assertEqual("Long... [null, null]", obj.resolve_Number_Long(None, None)) self.assertEqual("Number... [42]", obj.resolve_Number_Long(cast(Number, Long(42)))) self.assertEqual("Number... null", obj.resolve_Number_Long(cast(jarray(Number), None))) self.assertEqual("Number... [null]", obj.resolve_Number_Long(cast(Number, None))) self.assertEqual("Number... [42]", obj.resolve_Number_Long(jarray(Number)([42]))) self.assertEqual("Number... [null]", obj.resolve_Number_Long(jarray(Number)([None])))