def testStringArray(self): test1 = self.__jp.Test1() self.assertEqual('Object', test1.testStringArray(self._i4impl)) self.assertEqual('Object', test1.testStringArray(1)) self.assertRaisesRegex( TypeError, 'Ambiguous overloads found', test1.testStringArray, None) self.assertEqual('String', test1.testStringArray('somestring')) self.assertEqual('String[]', test1.testStringArray([])) self.assertEqual('String[]', test1.testStringArray(['a', 'b'])) self.assertEqual('String[]', test1.testStringArray( JArray(java.lang.String, 1)(['a', 'b']))) self.assertEqual('Object', test1.testStringArray( JArray(JInt, 1)([1, 2])))
def list1d_to_java_array(a): """ Converts python list of primitive int or double to java array """ if type(a) is list: if type(a[0]) is int: return JArray(JInt)(a) elif type(a[0]) is float: return JArray(JDouble)(a) elif type(a[0]) is str: return JArray(JString)(a) else: return JArray(JObject)(a) else: raise TypeError("Not a list: " + str(a))
def _to_imglib_argb(source): address = _get_address(source) long_address = JLong(address) long_arr_source = JArray(JLong)(source.shape[::-1]) if not (source.dtype == np.dtype('int32') or source.dtype == np.dtype('uint32')): raise NotImplementedError("source.dtype must be int32 or uint32") if source.flags['CARRAY']: return NumpyToImgLibConversions.toARGB(long_address, *long_arr_source) else: stride = np.array(source.strides[::-1]) / source.itemsize long_arr_stride = JArray(JLong)(stride) return NumpyToImgLibConversionsWithStride.toARGB( long_address, long_arr_stride, long_arr_source)
def testCallWithArray(self): h2 = JClass('jpype.attr.Test1')() StringArray = JArray(JString) v = StringArray(["Foo", "bar"]) t = JClass('jpype.attr.Test1')() result = t.testStringArray(v) self.assertSequenceEqual(["Foo", "bar"], result)
def testCallWithArray(self): h2 = self.__jp.Test1() StringArray = JArray(JString) v = StringArray(["Foo", "bar"]) t = self.__jp.Test1() result = t.testStringArray(v) self.assertSequenceEqual(["Foo", "bar"], result)
def _to_imglib(source): address = _get_address(source) long_address = JLong(address) long_arr_source = JArray(JLong)(source.shape[::-1]) if not source.dtype in numpy_dtype_to_conversion_method: raise NotImplementedError( "Cannot convert dtype to ImgLib2 type yet: {}".format( source.dtype)) elif source.flags['CARRAY']: return numpy_dtype_to_conversion_method[source.dtype](long_address, *long_arr_source) else: stride = np.array(source.strides[::-1]) / source.itemsize long_arr_stride = JArray(JLong)(stride) return numpy_dtype_to_conversion_with_stride_method[source.dtype]( long_address, long_arr_stride, long_arr_source)
def assert_ndarray_equal_to_img(img, nparr): cursor = img.cursor() arr = JArray(JInt)(5) while cursor.hasNext(): y = cursor.next().get() cursor.localize(arr) # TODO: Imglib has inverted dimensions - extract this behavior into a helper function x = nparr[tuple(arr[::-1])] assert x == y
def testCallWithArrayMismatch(self): h2 = JClass('jpype.attr.Test1')() StringArray = JArray(JString) v = StringArray(["Foo", "bar"]) t = JClass('jpype.attr.Test1')() result = t.testStringArray(v) self.assertFalse([1, 2] == result) self.assertFalse(result == [1, 2]) self.assertTrue([1, 2] != result) self.assertTrue(result != [1, 2])
def test_step_not_enough_dims(self, ij_fixture, img): # Create a stepped img via Views Views = sj.jimport("net.imglib2.view.Views") steps = JArray(JLong)([2, 1, 1]) expected = Views.subsample(img, steps) expected = Views.dropSingletonDimensions(expected) # Create a stepped img via slicing notation actual = img[::2] for i in range(3): for j in range(4): assert expected[i, j] == actual[i, j]
def test_slice_and_step(self, ij_fixture, img): # Create a stepped img via Views Views = sj.jimport("net.imglib2.view.Views") intervaled = Views.hyperSlice(img, 0, 0) steps = JArray(JLong)([1, 2]) expected = Views.subsample(intervaled, steps) # Create a stepped img via slicing notation actual = img[:1, :, ::2] for i in range(3): for j in range(2): assert expected[i, j] == actual[i, j]
def _get_img(): # Create img CreateNamespace = sj.jimport("net.imagej.ops.create.CreateNamespace") dims = JArray(JLong)([1, 2, 3, 4, 5]) ns = ij_fixture.op().namespace(CreateNamespace) img = ns.img(dims) # Populate img with random data cursor = img.cursor() while cursor.hasNext(): val = random.random() cursor.next().set(val) return img
def testVarArgsCall(self): test1 = self.__jp.Test1() self.assertEqual('A,B...', test1.testVarArgs(self._a, [])) self.assertEqual('A,B...', test1.testVarArgs(self._a, None)) self.assertEqual('A,B...', test1.testVarArgs(self._a, [self._b])) self.assertEqual('A,A...', test1.testVarArgs(self._a, [self._a])) self.assertEqual('A,B...', test1.testVarArgs( self._a, [self._b, self._b])) self.assertEqual('B,B...', test1.testVarArgs( self._b, [self._b, self._b])) self.assertEqual('B,B...', test1.testVarArgs( self._c, [self._c, self._b])) self.assertEqual('B,B...', test1.testVarArgs( self._c, JArray(self._cclass, 1)([self._c, self._c]))) self.assertEqual('B,B...', test1.testVarArgs(self._c, None)) self.assertEqual('B,B...', test1.testVarArgs(None, None))
def load_jar_class(jar_path, class_name): """ Load a class at runtime directly from a jar file. Note that with some libraries this can cause problems because the library will not be *visible* to the default class loader. :param jar_path: Path to the `.jar` file. :param class_name: The fully qualified Class Name within the jar to load. :return: """ URL = JClass('java.net.URL') URLClassLoader = JClass('java.net.URLClassLoader') Class = JClass('java.lang.Class') UrlArray = JArray(URL) urls = UrlArray(1) urls[0] = get_url(jar_path) java_class = JClass(Class.forName(class_name, True, URLClassLoader(urls))) return java_class
def getOptionalInstance(x): if type(x) is list: internalObjects = list(getOptionalInstance(thing) for thing in x) className = JClass(internalObjects[0].getClass().getName()) retVal = JArray(className, 1)(internalObjects) return retVal if type(x) is dict: # local import necessary to avoid a circular dependency - import it when you need it from blnx.java.util.HashMap import JHashMap hashMap = JHashMap() for key,value in x.items(): hashMap.put(key, getOptionalInstance(value)) return hashMap if hasattr(x, 'instance'): return x.instance else: return x
def get_faacets_moment_matrix(A_configuration, B_configuration, coefficients): from jpype import startJVM, shutdownJVM, JPackage, getDefaultJVMPath, \ JArray, JDouble # find the JAR file and start the JVM jarFiles = glob.glob('faacets-*.jar') assert len(jarFiles) == 1 jarFile = os.path.join(os.getcwd(), jarFiles[0]) startJVM(getDefaultJVMPath(), "-Djava.class.path=" + jarFile) com = JPackage('com') # main code sc = com.faacets.Core.Scenario( configuration_to_faacets(A_configuration, B_configuration)) representation = com.faacets.Core.Representation('NCRepresentation') ope = com.faacets.SDP.OperatorElements(['', 'A', 'AB']) pts = com.faacets.SDP.PartialTransposes([]) vec = com.faacets.Core.QVector(JArray(JDouble)(coefficients)) expr = com.faacets.Core.Expr(sc, representation, vec) sdp = com.faacets.SDP.CorrSDP(sc, ope, pts, expr.symmetryGroup()) M = np.array(sdp.indexArray()) ncIndices = np.array(sdp.ncIndices()) shutdownJVM() return M, ncIndices
def testObjectArraySimple(self) : a = JArray(java.lang.String, 1)(2) a[1] = "Foo" self.assertEqual("Foo", a[1])
def testByteArraySimple(self) : a = JArray(JByte)(2) a[1] = 2 self.assertEqual(a[1], 2)
def convert_map_to_vector(map, label_index): v = np.empty(len(map), dtype=float) for e in map: v[label_index[e]] = map[e] return JArray(JFloat, v.ndim)(v.tolist()) # 将numpy数组转为Java数组
def convert_map_to_matrix(map, label_index1, label_index2): m = np.empty((len(label_index1), len(label_index2)), dtype=float) for line in map: for col in map[line]: m[label_index1[line]][label_index2[col]] = map[line][col] return JArray(JFloat, m.ndim)(m.tolist())
def rai_slice(rai, imin: Tuple, imax: Tuple, istep: Tuple): """Slice ImgLib2 images. Slice ImgLib2 images using Python's slice notation to define the desired slice range. Returned interval includes both imin and imax :param rai: An ImgLib2 RandomAccessibleInterval :param imin: Tuple of minimum interval range values. :param imax: Tuple of maximum interval range values. :return: Sliced ImgLib2 RandomAccisbleInterval. """ # HACK: Avoid importing JLong at global scope. # Otherwise, building the sphinx docs in doc/rtd fails with: # # Warning, treated as error: # autodoc: failed to determine imagej.stack.JLong (<java class 'JLong'>) to be documented, the following exception was raised: # Java Virtual Machine is not running # # Which can be reproduced in a REPL like this: # # >>> from jpype import JLong # >>> help(JLong) # # So while the import here is unfortunate, it avoids the issue. from jpype import JArray, JLong Views = sj.jimport("net.imglib2.view.Views") shape = rai.shape imin_fix = JArray(JLong)(len(shape)) imax_fix = JArray(JLong)(len(shape)) dim_itr = range(len(shape)) for py_dim, j_dim in zip(dim_itr, dim_itr): # Set minimum if imin[py_dim] == None: index = 0 else: index = imin[py_dim] if index < 0: index += shape[j_dim] imin_fix[j_dim] = JLong(index) # Set maximum if imax[py_dim] == None: index = shape[j_dim] - 1 else: index = imax[py_dim] if index < 0: index += shape[j_dim] imax_fix[j_dim] = JLong(index) istep_fix = JArray(JLong)(istep) if _index_within_range(imin_fix, shape) and _index_within_range( imax_fix, shape): intervaled = Views.interval(rai, imin_fix, imax_fix) stepped = Views.subsample(intervaled, istep_fix) # TODO: better mach NumPy squeeze behavior. See pyimagej/#1231 dimension_reduced = Views.dropSingletonDimensions(stepped) return dimension_reduced
B = convert_map_to_matrix(emission_probability, states_label_index, observations_label_index) observations_index = convert_observations_to_index(observations, observations_label_index) pi = convert_map_to_vector(start_probability, states_label_index) FirstOrderHiddenMarkovModel = JClass( 'com.hankcs.hanlp.model.hmm.FirstOrderHiddenMarkovModel') given_model = FirstOrderHiddenMarkovModel(pi, A, B) for O, S in given_model.generate(3, 5, 2): print(" ".join((observations_index_label[o] + '/' + states_index_label[s]) for o, s in zip(O, S))) trained_model = FirstOrderHiddenMarkovModel() trained_model.train(given_model.generate(3, 10, 100000)) assert trained_model.similar(given_model) trained_model.unLog() # 将对数形式的概率还原回来 print(trained_model.start_probability) for vec in trained_model.transition_probability: print(vec) for vec in trained_model.emission_probability: print(vec) pred = JArray(JInt, 1)([0, 0, 0]) prob = given_model.predict(observations_index, pred) print(" ".join((observations_index_label[o] + '/' + states_index_label[s]) for o, s in zip(observations_index, pred)) + " {:.3f}".format(np.math.exp(prob)))
from jpype import (JClass, JArray, getDefaultJVMPath, java, shutdownJVM, startJVM) startJVM(getDefaultJVMPath(), '-ea', f'-Djava.class.path=dnmso.jar', convertStrings=False) DnmsoFactory: JClass = JClass('domain.DnmsoFactory') LutefiskXPService: JClass = JClass('service.LutefiskXPService') DNMSO: JClass = JClass('domain.DNMSO') dnmsoFactory: DnmsoFactory = DnmsoFactory() targetDNMSO: DNMSO = dnmsoFactory.createDnmso() lutefiskXPService: LutefiskXPService = LutefiskXPService() lutefiskXPArgs: JArray( java.lang.String) = ["read", "-p", "Qtof_ELVISLIVESK.lut", "-n", "2"] targetDNMSO: DNMSO = lutefiskXPService.run(targetDNMSO, lutefiskXPArgs) print(targetDNMSO.getPredictions().get(0).getPrediction().size())
def testCallWithArray(self): h2 = self.__jp.Test1() StringArray = JArray(JString) v = StringArray(["Foo", "bar"]) t = self.__jp.Test1() t.testStringArray(v)
def execute(self, operation, params=None): """ Execute a sql statement with an optional set of parameters :param operation: Sql text :param params: a sequence or dictionary of parameters Parameters can be positional templates ``%s`` or named templates ``:name`` :param operation: :param params: :return: """ if not self._connection_valid(): raise Error('the connection has been closed') self._reset() conn = self._connection.jdbc_connection() # handle parameters if params is not None: operation, params = self._parse_params(operation, params) # prepare the statement self._statement = stmt = conn.prepareStatement(operation) stmt.clearParameters() for column, value in enumerate(params or [], start=1): # note that in JDBC the first column index is 1 if isinstance(value, str): jvalue = JString(value) stmt.setString(column, jvalue) elif isinstance(value, float): jvalue = JDouble(value) stmt.setDouble(column, jvalue) elif isinstance(value, int): try: jvalue = JInt(value) stmt.setInt(column, jvalue) except Exception: jvalue = JLong(value) stmt.setLong(column, jvalue) elif isinstance(value, bool): jvalue = JBoolean(value) stmt.setBoolean(column, jvalue) elif isinstance(value, bytes): ByteArray = JArray(JByte) jvalue = ByteArray(value.decode('utf-8')) stmt.setBytes(column, jvalue) else: stmt.setObject(column, value) try: has_resultset = stmt.execute() except JClass('org.apache.hive.service.cli.HiveSQLException') as e: raise ProgrammingError('Error executing statement:\n{}\n{}'.format( operation, e)) from None self._rowcount = -1 if has_resultset: self._resultset = resultset = stmt.getResultSet() self._metadata = resultset.getMetaData() # get rowcount if self._get_rowcounts: try: if self._resultset.last( ): # if the cursor can be moved to the last row. self._rowcount = resultset.getRow() resultset.beforeFirst() except JClass('java.sql.SQLException'): # ResultSet.last() is not supported pass else: try: self._rowcount = stmt.getUpdateCount() except JClass('java.sql.SQLException'): # not supported pass
def ndarray_to_stallone_array(pyarray, copy=True): """ Convert numpy ndarrays to the corresponding wrapped type in Stallone. Currently only int32 and double are supported in stallone. Parameters ---------- pyarray : numpy.ndarray or scipy.sparse type one or two dimensional copy : boolean if false, a Java side ByteBuffer wrapping the given array buffer will be used to avoid a copy. This is useful for very huge data sets. Returns ------- IDoubleArray or IIntArray depending on input type Note: ----- scipy.sparse types will be currently converted to dense, before passing them to the java side! """ if not isinstance(pyarray, _np.ndarray): raise TypeError('Only numpy arrays supported. Given type was "%s"' % type(pyarray)) if pyarray.dtype not in _supported_types: raise TypeError('Given type %s not mapped in stallone library' % pyarray.dtype) """ from scipy.sparse.base import issparse if issparse(pyarray): _log.warning("converting sparse object to dense for stallone.") pyarray = pyarray.todense() """ shape = pyarray.shape dtype = pyarray.dtype factory = None cast_func = None # stallone does currently support only wrappers for int32 and float64 if dtype == _np.float32: _warnings.warn("Upcasting floats to doubles!") pyarray = pyarray.astype(_np.float64) if dtype == _np.int64: _warnings.warn("Downcasting long to 32 bit integer." " You will loose precision by doing so!") pyarray = pyarray.astype(_np.int32) # Pass memory to jpype and create a java array. # Also set corresponding factory method in stallone to wrap the array. if dtype == _np.float32 or dtype == _np.float64: factory = API.doublesNew cast_func = JDouble elif dtype == _np.int32 or dtype == _np.int64: factory = API.intsNew cast_func = JInt if not copy: if not pyarray.flags.c_contiguous: raise RuntimeError('Can only pass contiguous memory to Java!') jbuff = _nio.convertToDirectBuffer(pyarray) rows = shape[0] cols = 1 if len(shape) == 1 else shape[1] return factory.arrayFrom(jbuff, rows, cols) if len(shape) == 1: # create a JArray wrapper jarr = JArray(cast_func)(pyarray) if cast_func is JDouble: return factory.array(jarr) if cast_func is JInt: return factory.arrayFrom(jarr) raise TypeError('type not mapped to a stallone factory') elif len(shape) == 2: # TODO: use linear memory layout here, when supported in stallone jarr = JArray(cast_func, 2)(pyarray) if cast_func is JDouble: # for double arrays A = factory.array(jarr) elif cast_func is JInt: # for int 2d arrays A = factory.table(jarr) else: raise TypeError('type not mapped to a stallone factory') return A else: raise ValueError('unsupported shape:', shape)
def testObjectArraySimple(self): a = JArray(java.lang.String, 1)(2) a[1] = "Foo" assert "Foo" == a[1]
def testByteArraySimple(self): a = JArray(JByte)(2) a[1] = 2 assert a[1] == 2
def testBytes(self): UTF_8 = java.nio.charset.StandardCharsets.UTF_8 smiley = java.lang.String( JArray(JByte)([0xF0, 0x9F, 0x98, 0x8A]), UTF_8) self.assertEqual(list(smiley.getBytes(UTF_8)), [0xF0, 0x9F, 0x98, 0x8A])