def startJVM(self):
global mbeanServer,dominio,puerto
print os.path.abspath('.')
classpath = os.path.join(os.path.abspath('.'))
print jpype.getDefaultJVMPath()
jpype.startJVM(jpype.getDefaultJVMPath(), '-Djava.awt.headless=true',"-ea", "-Dvisualvm.display.name="+dominio+":"+str(puerto), "-Dcom.sun.management.jmxremote", "-Dcom.sun.management.jmxremote.port="+str(puerto), "-Dcom.sun.management.jmxremote.authenticate=false", "-Dcom.sun.management.jmxremote.ssl=false", "-Djava.class.path=simple-xml-2.6.9.jar:%s" % classpath)
mbeanServer = java.lang.management.ManagementFactory.getPlatformMBeanServer();
def jvm(max_mem=4000):
"""Return the jpype module, after guaranteeing the JVM is running and
the classpath has been loaded properly."""
jarpaths = (os.path.abspath(
os.path.join(os.path.dirname(__file__), "../lib")),
os.path.abspath(
os.path.join(os.path.dirname(__file__), "../dist")))
# TODO(JMC): Make sure these directories exist
# LOG.debug("Jarpath is %s", jarpaths)
if not jpype.isJVMStarted():
LOG.debug("Default JVM path is %s" % jpype.getDefaultJVMPath())
jpype.startJVM(jpype.getDefaultJVMPath(),
"-Djava.ext.dirs=%s:%s" % jarpaths,
#"-Dnet.spy.log.LoggerImpl=net.spy.memcached.compat.log.Log4JLogger",
# "-Dlog4j.debug",
"-Dlog4j.configuration=log4j.properties",
"-Dlog4j.rootLogger=%s, A1" % (FLAGS.debug.upper()),
# "-Dlog4j.rootLogger=DEBUG, A1",
"-Xmx%sM" % max_mem)
if FLAGS.capture_java_debug:
mystream = jpype.JProxy("org.gem.IPythonPipe", inst=sys.stdout)
errstream = jpype.JProxy("org.gem.IPythonPipe", inst=sys.stderr)
outputstream = jpype.JClass("org.gem.PythonOutputStream")()
err_stream = jpype.JClass("org.gem.PythonOutputStream")()
outputstream.setPythonStdout(mystream)
err_stream.setPythonStdout(errstream)
ps = jpype.JClass("java.io.PrintStream")
jpype.java.lang.System.setOut(ps(outputstream))
jpype.java.lang.System.setErr(ps(err_stream))
return jpype
def jvm(max_mem=None):
"""Return the jpype module, after guaranteeing the JVM is running and
the classpath has been loaded properly."""
jarpaths = (os.path.abspath(
os.path.join(os.path.dirname(__file__), "../lib")),
os.path.abspath(
os.path.join(os.path.dirname(__file__), "../dist")))
log4j_properties_path = os.path.abspath(
os.path.join(os.path.dirname(__file__),
"../log4j.properties"))
if not jpype.isJVMStarted():
max_mem = get_jvm_max_mem(max_mem)
LOG.debug("Default JVM path is %s" % jpype.getDefaultJVMPath())
jpype.startJVM(jpype.getDefaultJVMPath(),
"-Djava.ext.dirs=%s:%s" % jarpaths,
# "-Dlog4j.debug", # turn on log4j internal debugging
"-Dlog4j.configuration=file://%s" % log4j_properties_path,
"-Xmx%sM" % max_mem)
# override the log level set in log4j configuration file this can't be
# done on the JVM command line (i.e. -Dlog4j.rootLogger= is not
# supported by log4j)
_set_java_log_level(FLAGS.debug.upper())
if FLAGS.capture_java_debug:
_setup_java_capture(sys.stdout, sys.stderr)
return jpype
def testStartup(self):
# Test that we are robust to multiple startJVM
try:
self.assertRaises(OSError, jpype.startJVM, jpype.getDefaultJVMPath())
self.assertRaises(OSError, jpype.startJVM, jpype.getDefaultJVMPath())
except RuntimeError:
pass
# Verify that we don't crash after repeat
jpype.JClass("java.lang.String")
def startJvm():
import os
os.environ.setdefault("STANFORD_PARSER_HOME", "/Users/vgurswamy/Desktop/stanford-parser-python/3rdParty/stanford-parser/stanford-parser-2010-08-20")
global stanford_parser_home
stanford_parser_home = os.environ["STANFORD_PARSER_HOME"]
print jpype.getDefaultJVMPath()
print os.environ["STANFORD_PARSER_HOME"]
jpype.startJVM(jpype.getDefaultJVMPath(),
"-ea",
"-Djava.class.path=%s/stanford-parser.jar" % (stanford_parser_home),)
def runTest() : root = os.path.abspath(os.path.dirname(__file__)) print "Running testsuite using JVM", jpype.getDefaultJVMPath() jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Xmx256M", "-Xms64M", "-Djava.class.path=./classes%s%s%sclasses" % (os.pathsep, root, os.sep)) runner = unittest.TextTestRunner() runner.run(suite()) s = slice(2, 4) print s, dir(s) jpype.shutdownJVM()
def init_jpype():
build_dir = os.path.join(
os.path.abspath(os.path.split(__file__)[0]),
'build'
)
jpath = jpype.getDefaultJVMPath()
jpype.startJVM(jpath, "-ea", "-Djava.ext.dirs=%s" % build_dir)
def __startJVM(self):
"""
Initializes Java Virtual Machine and loads symmetrizer
"""
# Path to the jar file
jarpath = os.path.join(None)
try:
jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % (jarpath))
self._globJVMOn = True
self._globJVMJar = JPackage('net.webmo.symmetry').Main
messages.log(__name__, "JVM initialised!", verbose=1)
# Hello world from Java
jpype.java.lang.System.out.println("Java: hello world!")
#TODO: In future this should be done via streams
fs = jpype.JClass("java.io.File")
ps = jpype.JClass("java.io.PrintStream")
# Directing the output
jpype.java.lang.System.setOut(ps(fs(self._globJVMOutPath)))
jpype.java.lang.System.setErr(ps(fs(self._globJVMErrPath)))
except:
self._globJVMOn = False
self._globJVMJar = None
messages.warning(__name__, "Cannot start JVM!", verbose=0)
def classGen( ) :
global Modifier
root = os.path.abspath( os.path.dirname( __file__ ) )
cp = os.path.abspath(root+"/../../build-support/jasmin.jar;"+root+"/../../_bin;"+root+"/../../_classgen")
jpype.startJVM( jpype.getDefaultJVMPath( ), "-ea", "-Djava.class.path=%s"%cp)
Modifier = jpype.JClass( "java.lang.reflect.Modifier" )
try :
# base = jpype.JClass("javax.swing.JFrame")
base = jpype.JClass( "java.lang.Object" )
intf = [ jpype.JClass( "java.lang.Comparable" ),
#jpype.JClass("javax.swing.CellEditor"),
]
try :
result = generateClass( "com.darkwolf.jpype.classgen.TestClass", base, intf, "../../_classgen" );
dumpClassInformation( result );
except :
import traceback
traceback.print_exc( )
finally :
jpype.shutdownJVM( )
def __init__(self, connect, driver, user, password,isolation=''):
config_parser = SafeConfigParser()
config_parser.read(PATH_JDBC_CFG)
# since it is impossible to call jpype.isThreadAttachedToJVM() before jpype.startJVM()
# we won't check if JVM is started.
classpath = config_parser.get("JVM", "classpath")
javaHome = config_parser.get("JVM", "java_home")
if (javaHome[0] != '/'):
javaHome = "%s/%s" % (etl_util.get_app_root_path(), javaHome)
args='-Djava.class.path=%s' % classpath
try:
os.environ['JAVA_HOME'] = javaHome
jvm_path = jpype.getDefaultJVMPath()
except TypeError:
logging.error("failed to get default JVM path")
raise
if (jpype.isJVMStarted() == False):
jpype.startJVM(jvm_path, args)
logging.debug("Connecting with %s to %s with user %s" % (driver, connect, user))
self.conn = jaydebeapi.connect(driver, connect, user, password)
#set isolation level
if isolation!='':
if 'mysql' in driver:
sql='SET SESSION TRANSACTION ISOLATION LEVEL %s' % isolation
elif 'teradata' in driver:
sql='SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL %s' % isolation
self._execute(sql)
def _jdbc_connect_jpype(jclassname, jars, libs, *driver_args):
import jpype
if not jpype.isJVMStarted():
args = []
class_path = []
if jars:
class_path.extend(jars)
class_path.extend(_get_classpath())
if class_path:
args.append('-Djava.class.path=%s' %
os.path.pathsep.join(class_path))
if libs:
# path to shared libraries
libs_path = os.path.pathsep.join(libs)
args.append('-Djava.library.path=%s' % libs_path)
# jvm_path = ('/usr/lib/jvm/java-6-openjdk'
# '/jre/lib/i386/client/libjvm.so')
jvm_path = jpype.getDefaultJVMPath()
jpype.startJVM(jvm_path, *args)
if not jpype.isThreadAttachedToJVM():
jpype.attachThreadToJVM()
if _jdbc_name_to_const is None:
types = jpype.java.sql.Types
types_map = {}
for i in types.__javaclass__.getClassFields():
types_map[i.getName()] = i.getStaticAttribute()
_init_types(types_map)
global _java_array_byte
if _java_array_byte is None:
def _java_array_byte(data):
return jpype.JArray(jpype.JByte, 1)(data)
# register driver for DriverManager
jpype.JClass(jclassname)
return jpype.java.sql.DriverManager.getConnection(*driver_args)
def __init__(self, playerID):
jpype.startJVM(jpype.getDefaultJVMPath(), "-ea",
"-Djava.class.path=%s" % os.path.abspath("."))
Move = jpype.JClass("kalah.Move")
self.jmove = Move(playerID)
Player.__init__(self, playerID)
def runTest() :
root = os.path.abspath(os.path.dirname(__file__))
print(("Running testsuite using JVM: {0}".format(jpype.getDefaultJVMPath())))
jpype.startJVM(jpype.getDefaultJVMPath(),
"-ea", "-Xmx256M", "-Xms64M",
"-Djava.class.path={0}" \
.format(os.path.join(root, "classes")))
runner = unittest.TextTestRunner()
runner.run(suite())
s = slice(2, 4)
print("{0} {1}".format(s, dir(s)))
jpype.shutdownJVM()
def initJava(JAVA_HOME=None, SX_JAR=None):
global gIsJavaInitialized
if gIsJavaInitialized:
return
if not JAVA_HOME:
JAVA_HOME = SX_environ.get_JAVA_HOME()
if not SX_JAR:
SX_JAR = SX_environ.get_SX_JAR()
os.environ['JAVA_HOME'] = JAVA_HOME
options = [
'-Djava.class.path=%s' % SX_JAR
]
jvmPath = jpype.getDefaultJVMPath()
if not jvmPath:
jvmPath = os.path.join(JAVA_HOME, "bin", "client", "jvm.dll")
if not os.path.isfile(jvmPath):
print >>sys.stderr, "JVM dll doesn't exist at %s" % jvmPath
return False
try:
print "Before Start"
jpype.startJVM(jvmPath, *options)
print "After Start"
except:
traceback.print_exc()
return False
gIsJavaInitialized = True
return True
def init_jvm(jvmpath=None):
"""Initializes the Java virtual machine (JVM).
:param jvmpath: The path of the JVM. If left empty, inferred by :py:func:`jpype.getDefaultJVMPath`.
"""
if jpype.isJVMStarted():
logging.warning('JVM is already running. Do not init twice!')
return
folder_suffix = ['{0}', '{0}{1}bin',\
'{0}{1}jhannanum-0.8.4.jar',\
'{0}{1}kkma-2.0.jar',\
'{0}{1}komoran-2.4-e.jar',\
'{0}{1}shineware-common-2.0.jar', '{0}{1}shineware-ds-1.0.jar',\
'{0}{1}snakeyaml-1.12.jar', '{0}{1}scala-library-2.11.4.jar', '{0}{1}twitter-korean-text-2.4.3.jar', '{0}{1}twitter-text-1.10.1.jar',\
'{0}{1}*']
javadir = '%s%sjava' % (utils.installpath, os.sep)
args = [javadir, os.sep]
classpath = os.pathsep.join(f.format(*args) for f in folder_suffix)
jvmpath = jvmpath or jpype.getDefaultJVMPath()
if jvmpath:
jpype.startJVM(jvmpath, '-Djava.class.path=%s' % classpath,\
'-Dfile.encoding=UTF8',\
'-ea', '-Xmx768m')
else:
raise ValueError("Please specify the JVM path.")
def startCli() :
# These are the lines to start up the the java <--> python bridge
# We add the lib directory to the jar path, it expects there to be a jar
# of the OpenSHA + gem build.
# We also add the parent folder, so that the contents of the 'data' folder
# Can be accessed with getResource from within java
jarpath = os.path.join(os.path.abspath('..'), 'lib')
classpath = os.path.abspath('..')
jpype.startJVM(jpype.getDefaultJVMPath(), '-Djava.ext.dirs=%s:%s' % (jarpath, classpath))
# These lines are the same as the imports in Java
CalculatorConfigData = jpype.JClass(
'org.opensha.gem.GEM1.calc.gemLogicTreeProcessor.CalculatorConfigData')
LogicTreeProcessor = jpype.JClass(
'org.opensha.gem.GEM1.calc.gemLogicTreeProcessor.LogicTreeProcessor')
ErfLogicTreeData = jpype.JClass(
'org.opensha.gem.GEM1.calc.gemLogicTreeProcessor.ErfLogicTreeData')
GmpeLogicTreeData = jpype.JClass(
'org.opensha.gem.GEM1.calc.gemLogicTreeProcessor.GmpeLogicTreeData')
InputModelData = jpype.JClass(
'org.opensha.gem.GEM1.calc.gemLogicTreeProcessor.InputModelData')
# We can instantiate python classes as python-normal
# calculator = LogicTreeProcessor()
calcConfigData = CalculatorConfigData("CalculatorConfig.inp")
def jvm():
"""
Return the jpype module, after guaranteeing the JVM is running and
the classpath has been loaded properly.
"""
jarpaths = (os.path.abspath(
os.path.join(os.path.dirname(__file__), "../dist")),
'/usr/share/java')
if not jpype.isJVMStarted():
max_mem = get_jvm_max_mem()
jpype.startJVM(jpype.getDefaultJVMPath(),
"-Xmx%sM" % max_mem,
"-Djava.ext.dirs=%s:%s" % jarpaths,
# setting Schema path here is ugly, but it's better than
# doing it before all XML parsing calls
"-Dopenquake.nrml.schema=%s" % nrml.nrml_schema_file(),
# force the default Xerces parser configuration, otherwise
# some random system-installed JAR might override it
"-Dorg.apache.xerces.xni.parser.XMLParserConfiguration=" \
"org.apache.xerces.parsers.XIncludeAwareParserConfiguration")
_init_logs()
return jpype
def _jdbc_connect_jpype(jclassname, *args):
import jpype
# Ensure JVN is running
if not jpype.isJVMStarted():
jpype.startJVM(jpype.getDefaultJVMPath())
# Connect Jpype to JVM Thread
if not jpype.isThreadAttachedToJVM():
jpype.attachThreadToJVM()
# Initialize Type Conversion Mapping
if _converters is None:
types = jpype.java.sql.Types
types_map = {}
for i in types.__javaclass__.getClassFields():
types_map[i.getName()] = i.getStaticAttribute()
_init_converters(types_map)
global _java_array_byte
if _java_array_byte is None:
def _java_array_byte(data):
return jpype.JArray(jpype.JByte, 1)(data)
# register driver for DriverManager
jpype.JClass(jclassname)
return jpype.java.sql.DriverManager.getConnection(*args)
def __init__(self, class_schema_definition_dicts={}, class_abrv_lookup={}, \
use_weka_jvm=True, training_arff_features_list=[]):
self.class_schema_definition_dicts = class_schema_definition_dicts
self.training_arff_features_list = training_arff_features_list
self.arffmaker = arffify.Maker(search=[], \
skip_class=True, local_xmls=True, dorun=False, \
class_abrv_lookup=class_abrv_lookup)
if use_weka_jvm:
# TODO/NOTE: I think a WekaClassifier() class needs to be
# instantiated for each WEKA classification instance
# which uses a different .model and/or training .arff
# We initialize a Java virtual machine for Weka classifications
#try:
if not jpype.isJVMStarted():
#TODO / DEBUG: disable the next line for speed-ups once stable?
_jvmArgs = ["-ea"] # enable assertions
_jvmArgs.append("-Djava.class.path=" + \
os.environ["CLASSPATH"])
###20091905 dstarr comments out:
#_jvmArgs.append("-Xmx1000m")
_jvmArgs.append("-Xmx12000m") # 4000 & 5000m works, 3500m doesnt for some WEKA .models
jpype.startJVM(jpype.getDefaultJVMPath(), *_jvmArgs)
class_schema_name_list = self.class_schema_definition_dicts.keys()
class_schema_name_list.remove('mlens3 MicroLens')
class_schema_name_list.remove('Dovi SN')
class_schema_name_list.remove('General')
self.wc = {}
for class_schema_name in class_schema_name_list:
class_schema_dict = self.class_schema_definition_dicts[class_schema_name]
weka_training_model_fpath = class_schema_dict['weka_training_model_fpath']
weka_training_arff_fpath = class_schema_dict['weka_training_arff_fpath']
self.wc[class_schema_name] = weka_classifier.WekaClassifier( \
weka_training_model_fpath, weka_training_arff_fpath)
def start(heapSizeMiB=1024, enableAssertions=False, stackSizeMiB=None, garbageSizeMiB=None, allowRemoteManagement=False):
# build JVM launch args
args = [
jpype.getDefaultJVMPath(),
'-Xmx%dM' % heapSizeMiB,
'-Djava.class.path=%s' % makeClasspath()
]
if enableAssertions:
args.append("-ea")
if stackSizeMiB is not None:
args.append('-Xss%sM' % stackSizeMiB)
if garbageSizeMiB is not None:
args.append('-XX:MaxNewSize=%dM' % garbageSizeMiB)
if _nativesDir is not None:
args.append('-Djava.library.path=%s' % _nativesDir)
if allowRemoteManagement:
args.append('-Dcom.sun.management.jmxremote.ssl=false')
args.append('-Dcom.sun.management.jmxremote.authenticate=false')
args.append('-Dcom.sun.management.jmxremote.port=9010')
args.append('-Dcom.sun.management.jmxremote.rmi.port=9011')
args.append('-Djava.rmi.server.hostname=localhost')
args.append('-Dcom.sun.management.jmxremote.local.only=false')
# start the JVM
jpype.startJVM(*args)
# set up class factories
global c
c = Packages()
c.java = jpype.JPackage('java')
c.javax = jpype.JPackage('javax')
def start_JVM():
#only start JVM once since it is expensive
if (not jpype.isJVMStarted()):
#Use Brunel .jar files
lib_ext = "-Djava.ext.dirs=" + lib_dir
# headless execution of java is needed due to
# calls to AWT. See git issue #70
headless = "-Djava.awt.headless=true"
try:
#First use explicit path if provided
if brunel_util.JVM_PATH != "":
jpype.startJVM(brunel_util.JVM_PATH, headless, lib_ext)
else:
# Try jpype's default way
jpype.startJVM(jpype.getDefaultJVMPath(), headless, lib_ext)
except:
#jpype could not find JVM (this happens currently for IBM JDK)
#Try to find the JVM starting from JAVA_HOME either as a .dll or a .so
jvms = find_file('jvm.dll', os.environ['JAVA_HOME'])
if (not jvms):
jvms = find_file('libjvm.so', os.environ['JAVA_HOME'])
if (not jvms):
raise ValueError(
"No JVM was found. First be sure the JAVA_HOME environment variable has been properly "
"set before starting IPython. If it still fails, try to manually set the JVM using: "
"brunel.brunel_util.JVM_PATH=[path]. Where 'path' is the location of the JVM file (not "
"directory). Typically this is the full path to 'jvm.dll' on Windows or 'libjvm.so' on Unix ")
jpype.startJVM(jvms[0], headless, lib_ext)
def file2tasks(self, f1):
fr = open(f1, 'r')
tasks = []
for line in fr:
line = line.rstrip("\n")
arr2 = line.split("\t")
# path, params, tbin, tbout, time, line
tasks.append(
(arr2[0], arr2[2], arr2[5].split(",") if arr2[5] else [], arr2[6].split(",") if arr2[6] else [], float(arr2[7]), line))
fr.close()
out2id=dict([(ot, t[0]) for t in tasks for ot in t[3]])
id2time=dict([(t[0], t[4]) for t in tasks])
id2time["_end_"] = 0.0
edges=[(out2id[it], t[0], id2time[out2id[it]]) for t in tasks for it in t[2]]
edges += [(t[0], "_end_", id2time[t[0]]) for t in tasks]
vs = [id for id in id2time.keys()]
id2i = dict([(id, i) for i, id in enumerate(vs)])
edges2A4 = [(id2i[e[0]], id2i[e[1]], e[2]) for e in edges]
graphfile = f1 + ".graph"
graphfw = open(graphfile, 'w')
graphfw.write("%s\n" % len(id2i))
graphfw.write("%s\n" % len(edges2A4))
[graphfw.write("%s %s %s\n" %(e[0], e[1], e[2])) for e in edges2A4]
graphfw.close()
jarpath = "/home/wangdawei/github/algs4/target/algs4-1.0.0.0.jar"
jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % jarpath)
AcycleLPSort = jpype.JClass('edu.princeton.cs.algs4.AcycleLPSort')
acycleLPSort = AcycleLPSort()
res = acycleLPSort.sort(graphfile)
i2v = dict([(e.i, e.d) for e in res])
jpype.shutdownJVM()
return [(id, status, ins, outs, runtime, i2v[id2i[id]], line) for id, status, ins, outs, runtime, line in tasks]
def __init__(self, jar_filename=None, download_if_missing=False,
version=None, extra_jvm_args=None, start_jpype=True,
jvm_path=None):
"""extra_jvm_args can be set to a list of strings which will
be passed to your JVM. If start_jpype is True, we will start
a JVM via JPype if one hasn't been started already. The user is
responsible for stopping the JVM (jpype.shutdownJVM()) when they
are done converting. Once the JVM has been shutdown, you'll need
to create a new JPypeBackend in order to convert after that.
jvm_path is the path to libjvm.so (if None, will use JPype's
default JRE path)."""
StanfordDependencies.__init__(self, jar_filename, download_if_missing,
version)
if start_jpype and not jpype.isJVMStarted():
jpype.startJVM(jvm_path or jpype.getDefaultJVMPath(),
'-ea',
'-Djava.class.path=' + self.jar_filename,
*(extra_jvm_args or []))
self.corenlp = jpype.JPackage('edu').stanford.nlp
try:
self.acceptFilter = self.corenlp.util.Filters.acceptFilter()
except TypeError:
# this appears to be caused by a mismatch between CoreNLP and JRE
# versions since this method changed to return a Predicate.
version = jpype.java.lang.System.getProperty("java.version")
self._report_version_error(version)
trees = self.corenlp.trees
self.treeReader = trees.Trees.readTree
self.converter = trees.EnglishGrammaticalStructure
self.universal_converter = trees.UniversalEnglishGrammaticalStructure
# we now need to test whether we can actually create a universal
# converter -- we'll call it with invalid number of arguments
# since we don't want create a tree just for this
try:
self.universal_converter()
except TypeError:
# this is JPype's way of saying that it doesn't exist so we
# fall back to the original converter
self.universal_converter = self.converter
except RuntimeError as re:
# this means it exists but wanted a different number of arguments
# (in other words, we have a universal converter)
assert "No matching overloads found" in str(re)
try:
self.stemmer = \
self.corenlp.process.Morphology.stemStaticSynchronized
except AttributeError:
# stemStaticSynchronized was renamed in CoreNLP 3.6.0 to stemStatic
self.stemmer = \
self.corenlp.process.Morphology.stemStatic
puncFilterInstance = trees.PennTreebankLanguagePack(). \
punctuationWordRejectFilter()
try:
self.puncFilter = puncFilterInstance.test
except AttributeError:
self.puncFilter = puncFilterInstance.accept
self.lemma_cache = {}
def initjvm():
global _jvm_initialized
if (not _jvm_initialized):
LOG.debug("Starting JVM...")
startJVM(getDefaultJVMPath(), "-ea")
java.lang.System.out.println("JVM Running")
_jvm_initialized = True
def __init__(self, gui=False, thd=False):
'''
Create a link with netlogo. Underneath, the netlogo jvm is started
through jpype.
:param gui: boolean, if true run netlogo with gui, otherwise run in
headless mode. Defaults to false.
:param thd: boolean, if thrue start netlogo in 3d mode. Defaults to
false
'''
if not jpype.isJVMStarted():
# netlogo jars
jars = [NETLOGO_HOME + r'/lib/scala-library.jar',
NETLOGO_HOME + r'/lib/asm-all-3.3.1.jar',
NETLOGO_HOME + r'/lib/picocontainer-2.13.6.jar',
NETLOGO_HOME + r'/lib/log4j-1.2.16.jar',
NETLOGO_HOME + r'/lib/jmf-2.1.1e.jar',
NETLOGO_HOME + r'/lib/pegdown-1.1.0.jar',
NETLOGO_HOME + r'/lib/parboiled-core-1.0.2.jar',
NETLOGO_HOME + r'/lib/parboiled-java-1.0.2.jar',
NETLOGO_HOME + r'/lib/mrjadapter-1.2.jar',
NETLOGO_HOME + r'/lib/jhotdraw-6.0b1.jar',
NETLOGO_HOME + r'/lib/quaqua-7.3.4.jar',
NETLOGO_HOME + r'/lib/swing-layout-7.3.4.jar',
NETLOGO_HOME + r'/lib/jogl-1.1.1.jar',
NETLOGO_HOME + r'/lib/gluegen-rt-1.1.1.jar',
NETLOGO_HOME + r'/NetLogo.jar',
PYNETLOGO_HOME + r'/external_files/netlogoLink.jar']
# format jars in right format for starting java virtual machine
# TODO the use of the jre here is only relevant under windows
# apparently
# might be solvable by setting netlogo home user.dir
joined_jars = jar_separator.join(jars)
jarpath = '-Djava.class.path={}'.format(joined_jars)
jvm_handle = jpype.getDefaultJVMPath()
jpype.startJVM(jvm_handle, jarpath, "-Xms128M","-Xmx1024m")
jpype.java.lang.System.setProperty('user.dir', NETLOGO_HOME)
if sys.platform=='darwin':
jpype.java.lang.System.setProperty("java.awt.headless", "true");
debug("jvm started")
link = jpype.JClass('netlogoLink.NetLogoLink')
debug('NetLogoLink class found')
if sys.platform == 'darwin' and gui:
info('on mac only headless mode is supported')
gui=False
self.link = link(gui, thd)
debug('NetLogoLink class instantiated')
def fault_poly_from_mls(fault_source_geom, dip,
upp_seis_depth, low_seis_depth):
"""Given a fault source geometry (as a MultiLineString), dip, upper
seismogenic depth, lower seismogenic depth, and grid spacing (in km),
create a 3D polygon to represent the fault.
:param fault_source_geom:
:class:`django.contrib.gis.geos.collections.MultiLineString`
:param float dip:
Angle of dip, from 0.0 to 90.0 degrees (inclusive)
:param float upp_seis_depth:
Upper seismogenic depth
:param float low_seis_depth:
Lower seismogenic depth
:returns:
3D polygon representing the complete fault geometry
:rtype:
:class:`django.contrib.gis.geos.collections.Polygon`
"""
# I take no responsibility for writing this
#: Value is in kilometers
GRID_SPACING = 1.0
if not jpype.isJVMStarted():
# start jvm once
jpype.startJVM(jpype.getDefaultJVMPath(),
"-Djava.ext.dirs=%s" % settings.GEOCLUDGE_JAR_PATH)
FT = jpype.JClass('org.opensha.sha.faultSurface.FaultTrace')
LOC = jpype.JClass('org.opensha.commons.geo.Location')
LOC_LIST = jpype.JClass('org.opensha.commons.geo.LocationList')
SGS = jpype.JClass('org.opensha.sha.faultSurface.StirlingGriddedSurface')
coords = fault_source_geom.coords
fault_trace = FT('')
for line_str in coords:
for lon, lat in line_str:
# warning: the ordering of lat/lon is switched here
# be careful
loc = LOC(lat, lon)
fault_trace.add(loc)
surface = SGS(fault_trace, float(dip),
float(upp_seis_depth), float(low_seis_depth),
GRID_SPACING)
# now we make a polygon with the perimeter coords:
poly_coords = []
for per_loc in surface.getSurfacePerimeterLocsList():
lon = per_loc.getLongitude()
lat = per_loc.getLatitude()
depth = per_loc.getDepth()
poly_coords.append((lon, lat, depth))
return Polygon(poly_coords)
def setup_module(module):
# Module-level setup.
if not jpype.isJVMStarted():
jvm_args = [
'-Xmx%dM' % (MAX_JVM_HEAP_SIZE_BYTES // 1000 ** 2),
]
jpype.startJVM(jpype.getDefaultJVMPath(), *jvm_args)
module.JavaDoubleArray = jpype.JArray(jpype.JDouble, 1)
def _open(self):
logger.info("Starting JVM")
if isJVMStarted():
logger.warn("JVM is already started. Only one connection can be opened,"
"previously created connection will be used.")
return
startJVM(getDefaultJVMPath(), *self._jvm_args())
def test_jpype():
import jpype
import os.path
jarpath = '/homes/breeze/code/venv/lib' # os.path.join(os.path.abspath("."), "lib")
# print("-Djava.ext.dirs=%s" % jarpath)
# jpype.startJVM(jpype.getDefaultJVMPath(), "-Djava.ext.dirs=%s" % jarpath)
jpype.startJVM(jpype.getDefaultJVMPath(), '"-jar /homes/breeze/code/venv/lib/aspose-cells-17.4.0.jar"')
jpype.startJVM(jpype.getDefaultJVMPath(), "-Djava.class.path=%s" % jarpath)
jpype.java.lang.System.out.println("hello world")
document = jpype.JClass("com.aspose.cells.cells")
# document = jpype.JClass("com.aspose.words.Document")
doc = document()
print(doc, repr(doc))
# Copyright (c) 2019, RTE (http://www.rte-france.com)
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
# Note: this code requires pandas (pip install pandas)
import pypowsybl_core
import jpype
import jpype.imports
from jpype.types import *
jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", convertStrings=False)
# imports powsybl classes (java)
from java.nio.file import Path, Paths
from com.powsybl.loadflow import LoadFlow, LoadFlowResult, LoadFlowParameters
from com.powsybl.iidm.export import Exporters
from java.io import File
pimport = jpype.JPackage('com.powsybl.iidm.import_')
#simple dump network flows function
import pandas as pd
pd.set_option('display.max_columns', None)
pd.set_option('display.width', 200)
def dumpLinesFlowPandas(network, headline):
print("\n{}".format(headline))
lines = network.getLines()
import sys
import os
import time
from time import clock
from itertools import product
from array import *
import jpype as jp
sys.path.append("C:/MOOCs/CS 7641/proj2/ABAGAIL.jar")
jp.startJVM(jp.getDefaultJVMPath(), '-ea', '-Djava.class.path=/Users/jennyhung/MathfreakData/School/OMSCS_ML/Assign2/abagail_py/ABAGAIL/ABAGAIL.jar')
jp.java.io.FileReader
jp.java.io.File
jp.java.lang.String
jp.java.lang.StringBuffer
jp.java.lang.Boolean
jp.java.util.Random
jp.java.dist.DiscreteDependencyTree
jp.java.dist.DiscreteUniformDistribution
jp.java.opt.DiscreteChangeOneNeighbor
jp.java.opt.EvaluationFunction
jp.java.opt.EvaluationFunction
jp.java.opt.HillClimbingProblem
jp.java.opt.NeighborFunction
jp.java.opt.RandomizedHillClimbing
jp.java.opt.SimulatedAnnealing
jp.java.opt.example.FourPeaksEvaluationFunction
jp.java.opt.ga.CrossoverFunction
jp.java.opt.ga.SingleCrossOver
jp.java.opt.ga.DiscreteChangeOneMutation
jp.java.opt.ga.GenericGeneticAlgorithmProblem
jp.java.opt.GenericHillClimbingProblem
def _start_jvm_for_smoothnlp():
global STATIC_ROOT, SMOOTHNLP_JAR_PATH, PATH_CONFIG, SMOOTHNLP_JAR_VERSION
# Get ENV
ENVIRON = os.environ.copy()
# Load variables in Environment
if "SMOOTHNLP_STATIC_ROOT" in ENVIRON:
STATIC_ROOT = ENVIRON['SMOOTHNLP_STATIC_ROOT']
else:
from smoothnlp.static import STATIC_ROOT
if "SMOOTHNLP_JAR_PATH" in ENVIRON:
SMOOTHNLP_JAR_PATH = ENVIRON["SMOOTHNLP_JAR_PATH"]
else:
from smoothnlp.static import SMOOTHNLP_JAR_PATH
if "SMOOTHNLP_JVM_XMS" in ENVIRON:
SMOOTHNLP_JVM_XMS = ENVIRON["SMOOTHNLP_JVM_XMS"]
else:
SMOOTHNLP_JVM_XMS = "1300m"
if "SMOOTHNLP_JVM_XMX" in ENVIRON:
SMOOTHNLP_JVM_XMX = ENVIRON["SMOOTHNLP_JVM_XMX"]
else:
SMOOTHNLP_JVM_XMX = "2g"
PATH_CONFIG = os.path.join(STATIC_ROOT, 'smoothnlp.properties')
if not os.path.exists(SMOOTHNLP_JAR_PATH):
raise ValueError(
"配置错误: SMOOTHNLP_JAR_PATH = %s 不存在" %
SMOOTHNLP_JAR_PATH
)
elif not os.path.isfile(SMOOTHNLP_JAR_PATH) or not SMOOTHNLP_JAR_PATH.endswith('.jar'):
raise ValueError(
"配置错误:SMOOTHNLP_JAR_PATH =%s 不是jar 文件" %
SMOOTHNLP_JAR_PATH
)
else:
SMOOTHNLP_JAR_VERSION = os.path.basename(SMOOTHNLP_JAR_PATH)[len('smoothnlp-'):len('-jar-with-dependencies.jar')]
pathsep = os.pathsep
if platform.system().startswith('CYGWIN'):
jvmpath = getDefaultJVMPath()
if not jvmpath.startswith('/cygdrive'): # CYGWIN 使用了宿主机器的JVM，必须将路径翻译为真实路径
pathsep = ';'
if STATIC_ROOT.startswith('/usr/lib'):
cygwin_root = os.popen('cygpath -w /').read().strip().replace('\\', '/')
STATIC_ROOT = cygwin_root + STATIC_ROOT[len('/usr'):]
HANLP_JAR_PATH = cygwin_root + SMOOTHNLP_JAR_PATH[len('/usr'):]
PATH_CONFIG = cygwin_root + PATH_CONFIG[len('/usr'):]
elif STATIC_ROOT.startswith('/cygdrive'):
driver = STATIC_ROOT.split('/')
cygwin_driver = '/'.join(driver[:3])
win_driver = driver[2].upper() + ':'
HANLP_JAR_PATH = SMOOTHNLP_JAR_PATH.replace(cygwin_driver, win_driver)
STATIC_ROOT = STATIC_ROOT.replace(cygwin_driver, win_driver)
PATH_CONFIG = PATH_CONFIG.replace(cygwin_driver, win_driver)
JAVA_JAR_CLASSPATH = '-Djava.class.path=%s%s%s'%(
SMOOTHNLP_JAR_PATH,pathsep,STATIC_ROOT
)
# 加载插件 jar
for jar in glob.glob(os.path.join(STATIC_ROOT, '*.jar')):
if SMOOTHNLP_JAR_PATH.endswith(jar):
continue
JAVA_JAR_CLASSPATH = JAVA_JAR_CLASSPATH + pathsep + os.path.jion(STATIC_ROOT, jar)
# 启动JVM
if jpype.isJVMStarted():
return
else:
startJVM(
getDefaultJVMPath(),
JAVA_JAR_CLASSPATH,
'-Xms%s' % SMOOTHNLP_JVM_XMS,
'-Xmx%s' % SMOOTHNLP_JVM_XMX
)
def __init__(self):
if self.__inited is None:
jpype.startJVM(jpype.getDefaultJVMPath(), "-ea",
"-Djava.class.path=" + JavaTool.getAllJar())
self.__inited = True
# java
package com;
public class Test {
public String run(String str){
return str;
}
}
"""
// 编译
javac Test.java
// 打包，必须把整个目录（报名和目录名要对应）打包，否则无法访问类。
jar cvf test.jar com
"""
# python
import jpype
import os
jarpath = os.path.join(os.path.abspath('.'), 'test.jar')
jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % jarpath)
Test = jpype.JClass('com.Test')
# 或者通过JPackage引用Test类
# com = jpype.JPackage('com')
# Test = com.Test
t = Test()
res = t.run("a")
print (res)
jpype.shutdownJVM()
import os
env_GNATS_CLIENT_HOME = os.environ.get('GNATS_CLIENT_HOME')
str_GNATS_CLIENT_HOME = ""
if not (env_GNATS_CLIENT_HOME is None):
str_GNATS_CLIENT_HOME = env_GNATS_CLIENT_HOME + "/"
classpath = str_GNATS_CLIENT_HOME + "dist/gnats-client.jar"
classpath = classpath + ":" + str_GNATS_CLIENT_HOME + "dist/gnats-shared.jar"
classpath = classpath + ":" + str_GNATS_CLIENT_HOME + "dist/json.jar"
classpath = classpath + ":" + str_GNATS_CLIENT_HOME + "dist/rmiio-2.1.2.jar"
classpath = classpath + ":" + str_GNATS_CLIENT_HOME + "dist/commons-logging-1.2.jar"
startJVM(getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % classpath)
# Flight phase value definition
# You can detect and know the flight phase by checking its value
FLIGHT_PHASE_PREDEPARTURE = JPackage(
'com').osi.util.FlightPhase.FLIGHT_PHASE_PREDEPARTURE
FLIGHT_PHASE_ORIGIN_GATE = JPackage(
'com').osi.util.FlightPhase.FLIGHT_PHASE_ORIGIN_GATE
FLIGHT_PHASE_PUSHBACK = JPackage(
'com').osi.util.FlightPhase.FLIGHT_PHASE_PUSHBACK
FLIGHT_PHASE_RAMP_DEPARTING = JPackage(
'com').osi.util.FlightPhase.FLIGHT_PHASE_RAMP_DEPARTING
FLIGHT_PHASE_TAXI_DEPARTING = JPackage(
'com').osi.util.FlightPhase.FLIGHT_PHASE_TAXI_DEPARTING
FLIGHT_PHASE_RUNWAY_THRESHOLD_DEPARTING = JPackage(
'com').osi.util.FlightPhase.FLIGHT_PHASE_RUNWAY_THRESHOLD_DEPARTING
jdbcfilename = os.path.join(
os.path.dirname(os.path.realpath(__file__)), testjdbcfilename)
break
elif os.path.isfile(os.path.join(path, testjdbcfilename)):
jdbcfilename = os.path.join(path, testjdbcfilename)
break
if jdbcfilename == None:
logger.error(
"Cannot find JDBC library. Provide location with --jdbc-dir parameter."
)
sys.exit(
"Cannot find JDBC library. Provide location with --jdbc-dir parameter."
)
logger.info("Using JDBC library: " + jdbcfilename)
jHome = jpype.getDefaultJVMPath()
jpype.startJVM(jHome, '-Djava.class.path=' + jdbcfilename)
logger.info("Connecting to the DB...")
try:
connection_string = 'jdbc:oracle:thin:' + args.username + '/' + password + '@' + args.hostname + '/' + args.SID
logger.info("Connection string: " + 'jdbc:oracle:thin:' + args.username +
'/' + '**********' + '@' + args.hostname + '/' + args.SID)
conn = []
for i in range(0, 16):
conn.append(
jaydebeapi.connect('oracle.jdbc.driver.OracleDriver',
connection_string))
except Exception as e:
logger.error("Error: " + str(e))
sys.exit(1)
import jpype
import requests
import json
token_ct = '###############################'
dsn = '############################'
uid = '########'
pwd = '########'
tbl_m = 'METRO_STATUS'
tbl_w = 'WEATHER'
jar = 'db2jcc4.jar' # location of the jdbc driver jar
args='-Djava.class.path=%s' % jar
jvm = jpype.getDefaultJVMPath()
jpype.startJVM(jvm, args)
def exec_query(query):
conn = jaydebeapi.connect(
'com.ibm.db2.jcc.DB2Driver',
dsn,
[uid,pwd]
)
curs = conn.cursor()
if(isinstance(query, list)):
for stmt in query:
curs.execute(stmt)
else:
# _*_ coding:utf-8 _*_
import jpype
jvmPath = jpype.getDefaultJVMPath() # 默认的JVM路径
print(jvmPath)
jpype.startJVM(jvmPath)
jpype.java.lang.System.out.println("hello world!")
jpype.java.lang.System.out.println("I hate you!")
jpype.shutdownJVM()
def _init_jvm(self, zemberek_path):
if jp.isJVMStarted():
return
jp.startJVM(jp.getDefaultJVMPath(), '-ea',
'-Djava.class.path=%s' % zemberek_path)
# = Example 1 - Transfer entropy on binary data =
# Simple transfer entropy (TE) calculation on binary data using the discrete TE calculator:
import jpype
import random
import numpy
import os
# Change location of jar to match yours (we assume script is called from demos/python):
jarLocation = os.path.join(os.getcwd(), "..", "..", "infodynamics.jar");
if (not(os.path.isfile(jarLocation))):
exit("infodynamics.jar not found (expected at " + os.path.abspath(jarLocation) + ") - are you running from demos/python?")
# Start the JVM (add the "-Xmx" option with say 1024M if you get crashes due to not enough memory space)
jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=" + jarLocation)
# Generate some random binary data.
sourceArray = [random.randint(0,1) for r in range(100)]
destArray = [0] + sourceArray[0:99]
sourceArray2 = [random.randint(0,1) for r in range(100)]
# Create a TE calculator and run it:
teCalcClass = jpype.JPackage("infodynamics.measures.discrete").TransferEntropyCalculatorDiscrete
teCalc = teCalcClass(2,1)
teCalc.initialise()
# First use simple arrays of ints, which we can directly pass in:
teCalc.addObservations(sourceArray, destArray)
print("For copied source, result should be close to 1 bit : %.4f" % teCalc.computeAverageLocalOfObservations())
teCalc.initialise()
#随机生成指定位数随机的参数，
def random_test(digit):
f = ''
for i in range(0, digit):
a = random.randint(97, 122) #小写字母
b = random.randint(65, 90) #大写字母
c = random.randint(48, 57) #数字
d = [a, b, c]
e = chr(d[random.randint(0, 2)])
f = f + e
i += 1 #可有 可无(强迫症，去除i警告)
return f
#print random_test(20)
jvmPath = jpype.getDefaultJVMPath()
B = jpype.startJVM(jpype.getDefaultJVMPath(),
'-Djava.class.path=E:/pyhton_pay/pay_fun/sdk_pass.jar')
def pay_sdk_decrypt(s):
password = "******"
#s ="8QrYTDZCxnI1rCBAETOFuZFxCqhiD/NKtCuDRTmDS+k="
salt = [126, 27, 33, 64, 57, 76, 87, 98]
X = jpype.JClass('com.pay.common.PBECoder')
Y = jpype.JClass('com.pay.common.Coder')
#res=str((X.decrypt(Y.decryptBASE64(s),password,salt))).encode('utf-8')
try:
res = str((X.decrypt(Y.decryptBASE64(s), password,
salt))).encode('gbk')
except Exception:
if name.endswith('.jar'):
jars.append(resource_filename(__name__, "javalib/%s" % name))
if len(jars) > 0:
divider = ';' if sys.platform == "win32" else ':'
classpath = divider.join(jars)
jvm_args = ['-Djava.class.path=%s' % classpath]
if os.getenv('DEBUG', None) == 'true':
jvm_args.append('-Xdebug')
jvm_args.append('-Xnoagent')
jvm_args.append(
'-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000')
# run jvm
jpype.startJVM(jpype.getDefaultJVMPath(), *jvm_args)
NEO4J_JAVA_CLASSES = (
'org.neo4j.graphdb.Direction',
'org.neo4j.kernel.EmbeddedGraphDatabase',
'org.neo4j.tooling.GlobalGraphOperations',
'org.neo4j.graphdb.DynamicRelationshipType',
'java.util.HashMap',
)
for class_path in NEO4J_JAVA_CLASSES:
class_path = class_path.split('.')
package, class_name = '.'.join(class_path[:-1]), class_path[-1]
package = jpype.JPackage(package)
klass = getattr(package, class_name)
globals()[class_name] = klass
def path():
return jpype.getDefaultJVMPath()
def __init__(self, parent):
QWidget.__init__(self, parent)
self.buttonThread = QThread()
self.node = 'gui'
self.cost = 0
self.hsm_node = None
self.d = os.path.dirname(sys.modules['aui.mi'].__file__)
self.hid = nx.read_gpickle(os.path.join(self.d,
'networks/hid.gpickle'))
self.hsm = nx.get_node_attributes(self.hid, 'HSM')
self.hsm_evidence = {}
self.question = None
self.answerTimer = QTimer()
self.answerTimer.setSingleShot(True)
self.small_pause = QTimer()
self.decisionFormat = QTextCharFormat()
self.decisionFormat.setForeground(QtGui.QColor(76, 175, 80))
self.decisionFormat.setFontWeight(QtGui.QFont.Normal)
self.questionFormat = QTextCharFormat()
self.questionFormat.setForeground(QtGui.QColor(48, 131, 251))
self.questionFormat.setFontWeight(QtGui.QFont.Bold)
self.infoFormat = QTextCharFormat()
self.infoFormat.setFontWeight(QtGui.QFont.Normal)
self.infoFormat.setForeground(Qt.black)
self.evidence = {
'battery_level': 'Ok',
'wifi_level': 'Ok',
'LM': 'MV',
'focus': 'S',
'PC': 'AV',
'AS_visible': 'True',
'wifi_visible': 'True',
'battery_visible': 'True',
'C2': 'MV',
'C1': 'MV',
'AV_visible': 'True',
'GM': 'AV',
'joystick_direction': 'Backwards',
'SA': 'L2',
'SL': 'medium',
'CL': 'medium',
'Context': 'Exploration'
}
self.evidence = {}
self.decision_path = []
jvmPath = jpype.getDefaultJVMPath()
jarpath = os.path.join(os.path.abspath('.'),
'/Library/Java/Extensions/')
jpype.startJVM(jvmPath,
"-Djava.class.path=/Library/Java/Extensions/smile.jar")
self.net = JClass("smile.Network")
self.voi = JClass("smile.ValueOfInfo")
self.setupUi(self)
self.initUI()
def save_downscaled_grey_img(path_to_img, savefile_name, sc_factor,
img_width_to_match, img_height_to_match):
grey_img = Image.open(path_to_img).convert('L')
assert grey_img.size == (img_width_to_match, img_height_to_match), f"resolutions of images don't match but are" \
f"{grey_img.size} and ({img_width_to_match, img_height_to_match})"
grey_img_np = cv2.resize(np.array(grey_img, np.uint8),
None,
fx=sc_factor,
fy=sc_factor,
interpolation=cv2.INTER_AREA)
cv2.imwrite(savefile_name, grey_img_np)
print(f'Saved file {savefile_name}')
if __name__ == '__main__':
jpype.startJVM(jpype.getDefaultJVMPath())
parser = ArgumentParser()
parser.add_argument(
'--path_to_xml_lst',
default='',
type=str,
help="path to the lst file containing the file paths of the PageXMLs.")
parser.add_argument(
'--path_to_img_lst',
default='',
type=str,
help='path to the lst file containing the file paths of the images.')
parser.add_argument(
'--scaling_factor',
default=0.5,
type=float,
def __init__(self,
gui=False,
thd=False,
netlogo_home=None,
netlogo_version=None,
jvm_home=None,
jvmargs=[]):
if not netlogo_home:
netlogo_home = get_netlogo_home()
if not netlogo_version:
netlogo_version = establish_netlogoversion(netlogo_home)
if not jvm_home:
jvm_home = jpype.getDefaultJVMPath()
self.netlogo_home = netlogo_home
self.netlogo_version = netlogo_version
self.jvm_home = jvm_home
if sys.platform == 'win32':
jar_sep = ';'
else:
jar_sep = ':'
if not jpype.isJVMStarted():
jars = find_jars(netlogo_home)
jars.append(os.path.join(PYNETLOGO_HOME, 'java',
'netlogolink.jar'))
joined_jars = jar_sep.join(jars)
jarpath = '-Djava.class.path={}'.format(joined_jars)
jvm_args = [
jarpath,
] + jvmargs
try:
jpype.startJVM(jvm_home, *jvm_args)
except RuntimeError as e:
raise e
# enable extensions
if sys.platform == 'darwin':
exts = os.path.join(netlogo_home, 'extensions')
elif sys.platform == 'win32':
exts = os.path.join(netlogo_home, 'app', 'extensions')
else:
exts = os.path.join(netlogo_home, 'app', 'extensions')
# check if default extension folder exists, raise
# a warning otherwise
if os.path.exists(exts):
jpype.java.lang.System.setProperty('netlogo.extensions.dir',
exts)
else:
warnings.warn(
('could not find default NetLogo ',
'extensions folder. Extensions not ', 'available'))
if sys.platform == 'darwin':
jpype.java.lang.System.setProperty('java.awt.headless', 'true')
if not gui:
jpype.java.lang.System.setProperty('org.nlogo.preferHeadless',
'true')
link = jpype.JClass(module_name[self.netlogo_version])
if sys.platform == 'darwin' and gui:
gui = False
self.link = link(jpype.java.lang.Boolean(gui),
jpype.java.lang.Boolean(thd))
# -*- coding: utf-8 -*-
## Zemberek: Sentence Boundary Detection Example
# Documentation: https://github.com/ahmetaa/zemberek-nlp/tree/master/tokenization#sentence-boundary-detection
# Java Code Example: https://github.com/ahmetaa/zemberek-nlp/blob/master/examples/src/main/java/zemberek/examples/tokenization/SentenceBoundaryDetection.java
import jpype as jp
# Relative path to Zemberek .jar
ZEMBEREK_PATH = '../../bin/zemberek-full.jar'
# Start the JVM
jp.startJVM(jp.getDefaultJVMPath(), 'ea',
'-Djava.class.path=%s' % (ZEMBEREK_PATH))
# Import required Java classes
TurkishSentenceExtractor = jp.JClass(
'zemberek.tokenization.TurkishSentenceExtractor')
# Singleton instance with the default behavior
extractor = TurkishSentenceExtractor.DEFAULT
# A dummy paragraph to work on.
paragraph = 'Prof. Dr. Veli Davul açıklama yaptı. Kimse %6.5\'lik enflasyon oranını beğenmemiş!'
# Extracting the sentences from the paragraph into a list
sentences = extractor.fromParagraph(paragraph)
# Looping through the sentences...
for i, word in enumerate(sentences):
print('Sentence %d: %s' % (i + 1, word))
#!/usr/bin/python
import jpype
import os.path
# import jar files
jarpath = os.path.abspath('.')
jpype.startJVM(jpype.getDefaultJVMPath(), "-Djava.ext.dirs=%s" % jarpath)
# import java packages
java = jpype.JPackage('java')
core = jpype.JPackage('core')
datacenter = jpype.JPackage('datacenter')
generator = jpype.JPackage('generator')
math = jpype.JPackage('math')
stat = jpype.JPackage('stat')
StatName = jpype.JClass('core.Constants$StatName')
SocketPowerPolicy = jpype.JClass('datacenter.Socket$SocketPowerPolicy')
CorePowerPolicy = jpype.JClass('datacenter.Core$CorePowerPolicy')
# global stat requirements for statistical convergence
meanPrecision = .05
quantileSetting = .95
quantilePrecision = .05
warmupSamples = 5000
# this function creates an experiment
def createExperiment(xValues = []):
global meanPrecision, quantileSetting, quantilePrecision, warmupSamples
__author__ = 'fahadadeel'
import jpype
import os.path
from WorkingWithDocumentObject import RemoveMetadata
asposeapispath = os.path.join(os.path.abspath("../../../"), "lib")
print "You need to put your Aspose.Words for Java APIs .jars in this folder:\n"+asposeapispath
jpype.startJVM(jpype.getDefaultJVMPath(), "-Djava.ext.dirs=%s" % asposeapispath)
testObject = RemoveMetadata('data/')
testObject.main()
import time
import sys
sys.path.append(
'/Users/jennyhung/MathfreakData/School/OMSCS_ML/Assign2/abagail_py/ABAGAIL/ABAGAIL.jar'
)
print(sys.path)
import jpype as jp
import get_all_data
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
#jp.startJVM(jp.getDefaultJVMPath(), "-ea")
jp.startJVM(
jp.getDefaultJVMPath(), '-ea',
'-Djava.class.path=/Users/jennyhung/MathfreakData/School/OMSCS_ML/Assign2/abagail_py/ABAGAIL/ABAGAIL.jar'
)
jp.java.lang.System.out.println("hello world")
jp.java.func.nn.backprop.BackPropagationNetworkFactory
jp.java.func.nn.backprop.RPROPUpdateRule
jp.java.func.nn.backprop.BatchBackPropagationTrainer
jp.java.shared.SumOfSquaresError
jp.java.shared.DataSet
jp.java.shared.Instance
jp.java.opt.SimulatedAnnealing
jp.java.opt.example.NeuralNetworkOptimizationProblem
jp.java.opt.RandomizedHillClimbing
jp.java.ga.StandardGeneticAlgorithm
jp.java.func.nn.activation.RELU
def _start_jvm_for_hanlp():
global STATIC_ROOT, hanlp_installed_data_version, HANLP_JAR_PATH, PATH_CONFIG, HANLP_JAR_VERSION, HANLP_DATA_PATH
# Get ENV
ENVIRON = os.environ.copy()
# Load variables in Environment
if "HANLP_VERBOSE" in ENVIRON:
HANLP_VERBOSE = int(ENVIRON["HANLP_VERBOSE"])
else:
HANLP_VERBOSE = 0
if "HANLP_STATIC_ROOT" in ENVIRON:
STATIC_ROOT = ENVIRON["HANLP_STATIC_ROOT"]
if HANLP_VERBOSE:
print('使用环境变量 HANLP_STATIC_ROOT={}'.format(STATIC_ROOT))
HANLP_DATA_PATH = os.path.join(STATIC_ROOT, 'data')
def hanlp_installed_data_version():
return '手动安装'
else:
from pyhanlp.static import STATIC_ROOT, hanlp_installed_data_version, HANLP_DATA_PATH
if "HANLP_JAR_PATH" in ENVIRON:
HANLP_JAR_PATH = ENVIRON["HANLP_JAR_PATH"]
if HANLP_VERBOSE:
print('使用环境变量 HANLP_JAR_PATH={}'.format(HANLP_JAR_PATH))
else:
from pyhanlp.static import HANLP_JAR_PATH
if "HANLP_JVM_XMS" in ENVIRON:
HANLP_JVM_XMS = ENVIRON["HANLP_JVM_XMS"]
else:
HANLP_JVM_XMS = "1g"
if "HANLP_JVM_XMX" in ENVIRON:
HANLP_JVM_XMX = ENVIRON["HANLP_JVM_XMX"]
else:
HANLP_JVM_XMX = "2g"
PATH_CONFIG = os.path.join(STATIC_ROOT, 'hanlp.properties')
if not os.path.exists(HANLP_JAR_PATH):
raise ValueError("配置错误: HANLP_JAR_PATH=%s 不存在" % HANLP_JAR_PATH)
elif not os.path.isfile(HANLP_JAR_PATH) or not HANLP_JAR_PATH.endswith(
'.jar'):
raise ValueError("配置错误: HANLP_JAR_PATH=%s 不是jar文件" % HANLP_JAR_PATH)
elif not os.path.exists(STATIC_ROOT):
raise ValueError("配置错误: STATIC_ROOT=%s 不存在" % STATIC_ROOT)
elif not os.path.isdir(HANLP_DATA_PATH):
if HANLP_DATA_PATH.startswith(STATIC_ROOT):
raise ValueError("配置错误: STATIC_ROOT=%s 目录下没有data文件夹" % STATIC_ROOT)
else:
raise ValueError("配置错误: 数据包 %s 不存在，请修改配置文件中的root" %
HANLP_DATA_PATH)
elif not os.path.isfile(PATH_CONFIG):
raise ValueError("配置错误: STATIC_ROOT=%s 目录下没有hanlp.properties" %
STATIC_ROOT)
else:
HANLP_JAR_VERSION = os.path.basename(
HANLP_JAR_PATH)[len('hanlp-'):-len('.jar')]
if HANLP_VERBOSE:
print("加载 HanLP jar [%s] ..." % HANLP_JAR_PATH)
print("加载 HanLP config [%s/hanlp.properties] ..." % (STATIC_ROOT))
print("加载 HanLP data [%s/data] ..." % (STATIC_ROOT))
pathsep = os.pathsep
if platform.system().startswith('CYGWIN'):
jvmpath = getDefaultJVMPath()
if not jvmpath.startswith(
'/cygdrive'): # CYGWIN 使用了宿主机器的JVM，必须将路径翻译为真实路径
pathsep = ';'
if STATIC_ROOT.startswith('/usr/lib'):
cygwin_root = os.popen('cygpath -w /').read().strip().replace(
'\\', '/')
STATIC_ROOT = cygwin_root + STATIC_ROOT[len('/usr'):]
HANLP_JAR_PATH = cygwin_root + HANLP_JAR_PATH[len('/usr'):]
PATH_CONFIG = cygwin_root + PATH_CONFIG[len('/usr'):]
elif STATIC_ROOT.startswith('/cygdrive'):
driver = STATIC_ROOT.split('/')
cygwin_driver = '/'.join(driver[:3])
win_driver = driver[2].upper() + ':'
HANLP_JAR_PATH = HANLP_JAR_PATH.replace(
cygwin_driver, win_driver)
STATIC_ROOT = STATIC_ROOT.replace(cygwin_driver, win_driver)
PATH_CONFIG = PATH_CONFIG.replace(cygwin_driver, win_driver)
JAVA_JAR_CLASSPATH = "-Djava.class.path=%s%s%s" % (HANLP_JAR_PATH, pathsep,
STATIC_ROOT)
# 加载插件jar
for jar in glob.glob(os.path.join(STATIC_ROOT, '*.jar')):
if HANLP_JAR_PATH.endswith(jar):
continue
JAVA_JAR_CLASSPATH = JAVA_JAR_CLASSPATH + pathsep + os.path.join(
STATIC_ROOT, jar)
if HANLP_VERBOSE: print("设置 JAVA_JAR_CLASSPATH [%s]" % JAVA_JAR_CLASSPATH)
# 启动JVM
try:
startJVM(getDefaultJVMPath(),
JAVA_JAR_CLASSPATH,
"-Xms%s" % HANLP_JVM_XMS,
"-Xmx%s" % HANLP_JVM_XMX,
convertStrings=True)
except TypeError as e: # TypeError: startJVM() got an unexpected keyword argument 'convertStrings'
startJVM(getDefaultJVMPath(), JAVA_JAR_CLASSPATH,
"-Xms%s" % HANLP_JVM_XMS, "-Xmx%s" % HANLP_JVM_XMX)
def LoadHiveDataDetial(self, Hbase, Hive):
# Hive文档路径
eachHivePath = self.HiveDataPath + Hive + '.txt'
# Hive对应配置文档
confDataInfo = self.configInfo[Hbase]
if len(confDataInfo) == 6:
tableName = confDataInfo[0]
Des = confDataInfo[1]
conlumn = confDataInfo[2]
rowKeyDeli = confDataInfo[3]
valueDeli = confDataInfo[4]
flag = confDataInfo[5]
with open(eachHivePath, 'r') as EHP:
if flag == '1':
for line in EHP.readlines():
data_line = line.strip().split('\t')
roleKey = [
data_line[data] for data in rowKeyDeli.split(',')
]
roleKey.append("1")
value = [
data_line[data] for data in valueDeli.split(',')
]
yield roleKey
yield value
elif flag == '2':
for line in EHP.readlines():
data_line = line.strip().split('\t')
roleKey = [
data_line[data] for data in rowKeyDeli.split(',')
]
roleKey.append("2")
value = [
data_line[data] for data in valueDeli.split(',')
]
yield roleKey
yield value
elif flag == '3':
for line in EHP.readlines():
data_line = line.strip().split('\t')
roleKey = [
data_line[data] for data in rowKeyDeli.split(',')
]
value = [
data_line[data] for data in valueDeli.split(',')
]
yield roleKey
yield value
elif flag == '4':
jvmPath = jpype.getDefaultJVMPath()
jarpath = 'Month.jar'
jvmArg = '-Djava.class.path=%s' % jarpath
jpype.startJVM(jvmPath, '-ea', jvmArg)
javaClass = jpype.JClass("Month.MonthUtil")
javaInstance = javaClass()
date = datetime.datetime.now().strftime('%Y%m')
for line in EHP.readlines():
data_line = line.strip().split('\t')
roleKey = [
data_line[data] for data in rowKeyDeli.split(',')
]
roleKey.append(javaInstance.month2int(self.time))
value = [
data_line[data] for data in valueDeli.split(',')
]
yield roleKey
yield value
elif flag == '5':
jvmPath = jpype.getDefaultJVMPath()
jarpath = 'MD5.jar'
jvmArg = '-Djava.class.path=%s' % jarpath
jpype.startJVM(jvmPath, '-ea', jvmArg)
javaClass = jpype.JClass("MD5.MD5Utils")
javaInstance = javaClass()
for line in EHP.readlines():
data_line = line.strip().split('\t')
roleKey = [
javaInstance.getMD5Str(data_line[int(data)])
for data in rowKeyDeli.split(',')
]
value = [
Des + ':' + conlumn + ':' + data_line[int(data)]
for data in valueDeli.split(',')
]
yield roleKey
yield value
elif flag == '6':
roleKey_value = dict()
for line in EHP.readlines():
data_line = line.strip().split('\t')
roleKey = [
data_line[int(data)]
for data in rowKeyDeli.split(',')
]
value = [
Des + ':' + conlumn + ':' + data_line[int(data)]
for data in valueDeli.split(',')
]
roleKey_value[str(roleKey)] = str(value)
yield roleKey_value
else:
print("配置文件ConfigData有误!")
"""
Zemberek: Adding Dictionary Item Example
Java Code Example: https://bit.ly/2qTlmXb
"""
from os.path import join
from jpype import JClass, JString, getDefaultJVMPath, shutdownJVM, startJVM
if __name__ == '__main__':
ZEMBEREK_PATH: str = join('..', '..', 'bin', 'zemberek-full.jar')
startJVM(
getDefaultJVMPath(),
'-ea',
f'-Djava.class.path={ZEMBEREK_PATH}',
convertStrings=False
)
TurkishMorphology: JClass = JClass('zemberek.morphology.TurkishMorphology')
DictionaryItem: JClass = JClass(
'zemberek.morphology.lexicon.DictionaryItem'
)
RootAttribute: JClass = JClass('zemberek.core.turkish.RootAttribute')
PrimaryPos: JClass = JClass('zemberek.core.turkish.PrimaryPos')
SecondaryPos: JClass = JClass('zemberek.core.turkish.SecondaryPos')
WordAnalysis: JClass = JClass('zemberek.morphology.analysis.WordAnalysis')
morphology: TurkishMorphology = TurkishMorphology.createWithDefaults()
def runStringToByteArray(data):
print 'Running String conversion to byte array. size = ', len(
data) / 1024.0, 'kb'
start = time.time()
arr_cls = jpype.JArray(jpype.JByte)
java_arr = arr_cls(data)
end = time.time()
print ' test run in', (end - start), 'seconds.'
root = os.path.abspath(os.path.dirname(__file__))
jpype.startJVM(
jpype.getDefaultJVMPath(), "-ea", "-Xmx5M", "-verbose:gc",
"-Djava.class.path=./classes%s%s%sclasses" % (os.pathsep, root, os.sep))
DELETED = False
class MyStr(str):
def __del__(self):
global DELETED
print 'string got deleted'
DELETED = True
def testStringMemory():
print 'with keeping the data'
data = MyStr('5' * 1024)
# -*-coding:utf-8-*-
# python调用java
import jpype
from jpype import *
import os.path
inputFile = os.path.join(os.path.abspath('.'), r'input.txt')
mappingFile = os.path.join(os.path.abspath('.'), r'mapping.txt')
jar_path = os.path.join(os.path.abspath('.'), r'retrace.jar')
print(jar_path)
jvm_path = jpype.getDefaultJVMPath()
print(jvm_path)
# ext_path = os.path.join(os.path.abspath('.'), r'exts')
jpype.startJVM(jvm_path, '-ea', '-Djava.class.path=%s' % jar_path)
JClass = jpype.JClass('proguard.retrace.ReTrace')
inputs = '''Caused by: java.lang.RuntimeException: this is a test
at com.app.config.d.a(Unknown Source)
at com.app.config.MainActivity.onCreate(Unknown Source)
at android.app.Activity.performCreate(Activity.java:6682)
at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1118)
'''
# In[6]:
A = mg.load_dataset('table_A')
# In[7]:
A.head(10)
# In[8]:
import jpype
# In[9]:
jpype.getDefaultJVMPath()
# In[10]:
# Initialize JVM
mg.init_jvm('C:\\Program Files\\Java\\jre7\\bin\\server\\jvm.dll')
# In[11]:
# import toy datasets
A = mg.load_dataset('table_A')
B = mg.load_dataset('table_B')
# In[12]:
A
import re
from trstop import trstop
import string
from typing import List
from jpype import JClass, JString, getDefaultJVMPath, shutdownJVM, startJVM, java
from examples import DATA_PATH, ZEMBEREK_PATH
from pathlib import Path
startJVM(getDefaultJVMPath(), '-ea',
'-Djava.class.path=%s' % (ZEMBEREK_PATH))
TurkishMorphology: JClass = JClass('zemberek.morphology.TurkishMorphology')
TurkishSentenceNormalizer: JClass = JClass(
'zemberek.normalization.TurkishSentenceNormalizer'
)
Paths: JClass = JClass('java.nio.file.Paths')
morphology = TurkishMorphology.createWithDefaults()
def stem(text: str) -> str:
results: WordAnalysis = morphology.analyze(JString(text))
for result in results:
return str(result.getLemmas()[0])
normalizer = TurkishSentenceNormalizer(
TurkishMorphology.createWithDefaults(),
Paths.get(str(DATA_PATH.joinpath('normalization'))),
def startVM():
# Change location of jar to match yours:
#jarLocation = "\Users\casa\Documents\FF\infodynamics-dist-1.5\infodynamics.jar"
jarLocation ="\Library\Java\Extensions\infodynamics.jar"
# Start the JVM (add the "-Xmx" option with say 1024M if you get crashes due to not enough memory space)
jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=" + jarLocation)
def java(request):
jpype.startJVM(jpype.getDefaultJVMPath(), "-ea")
request.addfinalizer(jpype.shutdownJVM)
return jpype.java
def katechToWgs84(x, y):
if(type(x) != type(0.0) or type(y) != type(0.0)):
print "Parameters must be type of float"
return -1
"""
classpath = os.path.join(os.path.abspath('../'), 'bin')
jpype.startJVM(jpype.getDefaultJVMPath(), "-Djava.class.path=%s" % classpath)
"""
# jarpath = os.path.join(os.path.abspath('.'), 'GeoTrans.jar')
# jpype.startJVM(jpype.getDefaultJVMPath(), "-Djava.ext.dirs=%s" % jarpath)
# JVM Start
if not jpype.isJVMStarted():
jarpath = ".:GeoTrans.jar"
jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % (jarpath))
# Package Import
GeoPkg = jpype.JPackage("GeoTrans")
# Class Import
GeoPoint = GeoPkg.GeoPoint
GeoTrans = GeoPkg.GeoTrans
# Point convert
oKA = GeoPoint(x, y)
oGeo = GeoTrans.convert(GeoTrans.KATEC, GeoTrans.GEO, oKA)
return {"x":oGeo.getX(), "y":oGeo.getY()}
