Esempio n. 1
1
def startJVM():
  global JasperCompileManager, JasperFillManager, JasperExportManager, \
    JRPdfExporter, JRRtfExporter, JRHtmlExporter, JRXlsExporter, \
    JRExporterParameter, JRPdfExporterParameter, JRrtfExporterParameter, JRXlsExporterParameter, \
    JRLoader, JRParameter,JRXmlDataSource, JRXPathQueryExecuterFactory, JRXmlUtils

  _jvmArgs = ["-ea"] # enable assertions
  _jvmArgs.append("-Djava.ext.dirs=%s" % pathToJRLibs)
  jpype.startJVM(JVMPath, *_jvmArgs)
  #
  JasperCompileManager= jpype.JClass("net.sf.jasperreports.engine.JasperCompileManager")
  JasperFillManager= jpype.JClass("net.sf.jasperreports.engine.JasperFillManager")
  JasperExportManager= jpype.JClass("net.sf.jasperreports.engine.JasperExportManager")
  
  JRPdfExporter= jpype.JClass("net.sf.jasperreports.engine.export.JRPdfExporter")
  JRRtfExporter= jpype.JClass("net.sf.jasperreports.engine.export.JRRtfExporter")
  JRHtmlExporter= jpype.JClass("net.sf.jasperreports.engine.export.JRHtmlExporter")
  JRXlsExporter= jpype.JClass("net.sf.jasperreports.engine.export.JRXlsExporter")
  #
  JRParameter= jpype.JClass("net.sf.jasperreports.engine.JRParameter")
  JRExporterParameter= jpype.JClass("net.sf.jasperreports.engine.JRExporterParameter")
  JRPdfExporterParameter= jpype.JClass("net.sf.jasperreports.engine.export.JRPdfExporterParameter")
  JRXlsExporterParameter= jpype.JClass("net.sf.jasperreports.engine.export.JRXlsExporterParameter")
  
  JRLoader= jpype.JClass("net.sf.jasperreports.engine.util.JRLoader")
  JRXmlDataSource=jpype.JClass("net.sf.jasperreports.engine.data.JRXmlDataSource")
  JRXPathQueryExecuterFactory=jpype.JClass("net.sf.jasperreports.engine.query.JRXPathQueryExecuterFactory")
  JRXmlUtils=jpype.JClass("net.sf.jasperreports.engine.util.JRXmlUtils")
Esempio n. 2
0
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
Esempio n. 3
0
 def check(self, textkey, data, config):
     try:
         import jpype
         from jpype import java, javax
         
         if not jpype.isJVMStarted(): jpype.startJVM(config['jvm_path'])            
         jhash = java.util.HashMap()
         jarray = jpype.JArray(java.lang.String)([config['username'], config['password']])
         jhash.put(javax.management.remote.JMXConnector.CREDENTIALS, jarray)
         url = "service:jmx:rmi:///jndi/rmi://%s:%d/jmxrmi" % (config['host'], int(config['port']))
         jmxurl = javax.management.remote.JMXServiceURL(url)
         jmxsoc = javax.management.remote.JMXConnectorFactory.connect(jmxurl, jhash)
         connection = jmxsoc.getMBeanServerConnection()
         
         parts = data.split("/", 3)
         obj = parts[0]
         attribute = parts[1]
         if len(parts) == 3:
             key = parts[2] 
         else:
             key = None
         res = connection.getAttribute(javax.management.ObjectName(obj), attribute)
         if key: res = res.contents.get(key)            
         return res.floatValue()
     except:
         return 0
Esempio n. 4
0
    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)
Esempio n. 5
0
File: jvm.py Progetto: yamt/midonet
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
Esempio n. 6
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( )	
Esempio n. 7
0
    def _inner(*args, **kwargs):
        if not jpype.isJVMStarted():
            jpype.startJVM(jvm_path)

        ret_val = func(*args, **kwargs)

        return ret_val
Esempio n. 8
0
	def __init__(self,libjvm='/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.65-2.b17.el7_1.x86_64/jre/lib/amd64/server/libjvm.so'):
		try:
            		logger.debug(libjvm)
            		jpype.startJVM(libjvm)
        	except RuntimeError, e:
            		logger.error(e)
            		raise JVM_Import_Error()
Esempio n. 9
0
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")
Esempio n. 10
0
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
Esempio n. 11
0
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)
Esempio n. 12
0
    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]
Esempio n. 13
0
    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 __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 = {}
Esempio n. 15
0
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')
Esempio n. 16
0
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
Esempio n. 17
0
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.")
Esempio n. 18
0
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)
Esempio n. 19
0
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)
Esempio n. 20
0
    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)
Esempio n. 21
0
 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();
Esempio n. 22
0
  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)
Esempio n. 23
0
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
Esempio n. 24
0
    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')
Esempio n. 25
0
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)
Esempio n. 26
0
    def __init__(self):
        #~ jpype.startJVM('C:/Program Files (x86)/Java/jdk1.6.0_21/jre/bin/client/jvm.dll', '-Xmx800m')
        #~ jpype.startJVM(jpype.getDefaultJVMPath())
        jpype.startJVM('/usr/lib/jvm/java-6-openjdk/jre/lib/amd64/server/libjvm.so', '-Xmx2000m')

        nlpPackage = jpype.JPackage('edu').stanford.nlp
        self.lexicalizedParser = nlpPackage.parser.lexparser.LexicalizedParser('englishPCFG.ser.gz')
        self.grammaticalStructureFactory  = nlpPackage.trees.PennTreebankLanguagePack().grammaticalStructureFactory()
Esempio n. 27
0
    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())
Esempio n. 28
0
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)
Esempio n. 29
0
def startJvm():
    import os
    os.environ.setdefault("STANFORD_PARSER_HOME", "3rdParty/stanford-parser/stanford-parser-2010-08-20")
    global stanford_parser_home
    stanford_parser_home = os.environ["STANFORD_PARSER_HOME"]
    jpype.startJVM(jpype.getDefaultJVMPath(),
                   "-ea",
                   "-Djava.class.path=%s/stanford-parser.jar" % (stanford_parser_home),)
Esempio n. 30
0
import pandas as pd
import matplotlib.pyplot as plt
from pathlib import Path
Path.ls = lambda x: list(x.iterdir())

# In[3]:

import jpype, math, random
import os, sys
from jpype import *

# In[4]:

try:
    jarLocation = "/home/fsf/software/inforDynamics-dist-1.5/infodynamics.jar"
    jpype.startJVM(jpype.getDefaultJVMPath(), "-ea",
                   "-Djava.class.path=" + jarLocation)
except:
    print("JVM  has already started !")

# In[5]:

sys.path.append('../../srcs')

# In[6]:

from jidt.data import example1, example2

# In[7]:

x, y = example2(length=3000, noise_level=[0.1, 0.1])
Esempio n. 31
0
    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 = {}
Esempio n. 32
0
import os
import sys
import subprocess
packages = ['JPype1', 'selenium', 'tqdm', 'shapely']
for p in packages:
    subprocess.check_call([sys.executable, "-m", "pip", "install", p])
import argparse, posixpath, json
import numpy as np
import pandas as pd
import time
import jpype
from jpype import imports
from jpype.types import *
jpype.addClassPath('./lib/OpenSHA-1.5.2.jar')
jpype.startJVM("-Xmx8G", convertStrings=False)

from CreateStation import *
from CreateScenario import *
from ComputeIntensityMeasure import *
from SelectGroundMotion import *

if __name__ == '__main__':

    parser = argparse.ArgumentParser()
    parser.add_argument('--hazard_config')
    args = parser.parse_args()
    with open(args.hazard_config) as f:
        hazard_info = json.load(f)

    # Directory
Esempio n. 33
0
 def testRestart(self):
     with self.assertRaises(OSError):
         jpype.startJVM()
Esempio n. 34
0
  outformats - a dictionary of supported output formats
"""

import os
import sys

if sys.platform[:4] == "java": # Jython
    import uk.ac.cam.ch.wwmm.opsin as opsin
else: # CPython
    import jpype
    if not jpype.isJVMStarted():
        _jvm = os.environ['JPYPE_JVM']
        if _jvm[0] == '"': # Handle trailing quotes
            _jvm = _jvm[1:-1]
        _cp = os.environ['CLASSPATH']
        jpype.startJVM(_jvm, "-Djava.class.path=" + _cp)
    opsin = jpype.JPackage("uk").ac.cam.ch.wwmm.opsin
    
try:
    _nametostruct = opsin.NameToStructure.getInstance()
    _restoinchi = opsin.NameToInchi.convertResultToInChI
except TypeError:
    raise ImportError("The OPSIN Jar file cannot be found.")

informats = {'iupac': 'IUPAC name'}
"""A dictionary of supported input formats"""
outformats = {'cml': "Chemical Markup Language", 'inchi': "InChI",
              'smi': "SMILES"}
"""A dictionary of supported output formats"""

def readstring(format, string):
Esempio n. 35
0
import jpype
import numpy as np
from numpy import random

jpype.startJVM(jpype.getDefaultJVMPath())

random.seed(44)
values = np.random.randn(7)
java_array = jpype.JArray(jpype.JDouble, 1)(values.tolist())

for item in java_array:
    jpype.java.lang.System.out.println(item)

jpype.shutdownJVM()
# -*- coding: utf-8 -*-

## Zemberek: Document Correction Example
# Documentation: https://github.com/ahmetaa/zemberek-nlp/tree/master/normalization
# Java Code Example: https://github.com/ahmetaa/zemberek-nlp/blob/master/examples/src/main/java/zemberek/examples/normalization/CorrectDocument.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
TurkishSpellChecker = jp.JClass('zemberek.normalization.TurkishSpellChecker')
TurkishTokenizer = jp.JClass('zemberek.tokenization.TurkishTokenizer')
TurkishLexer = jp.JClass('zemberek.tokenization.antlr.TurkishLexer')
TurkishMorphology = jp.JClass('zemberek.morphology.TurkishMorphology')

# A dummy data to work on
dummy = (
    '     Türk Vatanı ve Milletinin ebedi varlığxını ve Yüce Türk Devlatinin bölünmez bütünlüğünü belirleyen bu Anayasa,\n'
    +
    'Türkiye Cumhuriyetinin kurucusu, ölümsüz önder ve eşsiz kahraman Atatürk’ün belirlediği milliyetçilik anlayışı ve onun\n'
    + 'inkılap ve ilkeleri doğrultusunda;\n' +
    'Dünya milletleri ailesinin eşit haklara sahip şerefli bir üyesi olarak, Türkiye Cumhuriyetinin ebedi varlığı, refahı,\n'
    +
    'maddi ve manelvi mutluluğu ile çağdaş medeniyet düzeyine ulaşma azmi yönünde;\n'
    +
Esempio n. 37
0
import cudf
import dask_cudf
import dask
import jpype
import dask.distributed
import netifaces as ni

import random

jpype.addClassPath(
    os.path.join(os.getenv("CONDA_PREFIX"), 'lib/blazingsql-algebra.jar'))
jpype.addClassPath(
    os.path.join(os.getenv("CONDA_PREFIX"), 'lib/blazingsql-algebra-core.jar'))

jvm_path = os.environ["CONDA_PREFIX"] + "/jre/lib/amd64/server/libjvm.so"
jpype.startJVM('-ea', convertStrings=False, jvmpath=jvm_path)

ArrayClass = jpype.JClass('java.util.ArrayList')
ColumnTypeClass = jpype.JClass(
    'com.blazingdb.calcite.catalog.domain.CatalogColumnDataType')
dataType = ColumnTypeClass.fromString("GDF_INT8")
ColumnClass = jpype.JClass(
    'com.blazingdb.calcite.catalog.domain.CatalogColumnImpl')
TableClass = jpype.JClass(
    'com.blazingdb.calcite.catalog.domain.CatalogTableImpl')
DatabaseClass = jpype.JClass(
    'com.blazingdb.calcite.catalog.domain.CatalogDatabaseImpl')
BlazingSchemaClass = jpype.JClass('com.blazingdb.calcite.schema.BlazingSchema')
RelationalAlgebraGeneratorClass = jpype.JClass(
    'com.blazingdb.calcite.application.RelationalAlgebraGenerator')
Esempio n. 38
0
def add_dependency_to_vec(words_vec,sentences_data,idx_2_w):
    '''
    参数说明
    words_vec:词向量数据,有如下属性:( words_vec.vocab :表示包含的所以词的词典,\
          如果 有个词 w 在words_vec.vocab中 ,可用 words_vec[w] 获得其词向量(100维))
    sentences_data:文本数据包含8w条左右的数据,如下所示:
              [ [1,3,6,7,9,0,0],
                [5,6,7,9,1,3,0],
                ....
                ....
                ....
              ]
             每句话由一个list表示,其中每一个数字表示词的编号
    idx_2_w:编号转词的词典,如词w编号5,可以根据idx_2_w[5]得到词w
    '''

    windowSize = 3
    jpype.startJVM(jpype.getDefaultJVMPath(),"-Djava.class.path=/home/gpu2/zhaozd/hanlp1/hanlp-1.2.9.jar:/home/gpu2/zhaozd/hanlp1", "-Xms1g", "-Xmx1g") # gai!!!
    HanLP = jpype.JClass('com.hankcs.hanlp.HanLP')
    #windowSize = 4  #依存关系最多提取10个孩子
    dep = []
    depLabel=[]
    f0 = open('../vae/depLabel.txt','r') #生成依存标签-编号字典 gai!!!
    i0 = 0
    for line in f0.readlines():
        dep.append(line.strip('\n'))
        depLabel.append(i0)
        i0+=1
    dictDep = {}
    dictDep=dict(zip(dep,depLabel))
    print ('依存关系类别词典建立完毕')
    mapping=words_vec   
    print ('词向量匹配中...')
    print ('提取依存序列')
    docIndex = [] #总
    allWord=[]
    for count in range(len(sentences_data)) :
        if count % 1000 ==0:
            print (count)
        sentIndex = [] #句存储list 包含每个词及他们的孩子编号序列
        sentWord = []        
        l = ' '.join([idx_2_w[int(x)] for x in sentences_data[count]])
        if l.strip('\n') != '' :
            linewrite0 = HanLP.parseDependency(l)
            lineData = linewrite0.toString().split('\n')
            lineData.pop()
            for ll in lineData: #针对每个词提取依存孩子序列
                if ll.strip() == '':
                    continue

    
                wordIndex = [] #词存储lixt 每个孩子依次加入
                '''
                该词词向量
                '''
                if ll.split('\t')[7] == '标点符号' :
                    for count in range(100) :
                        wordIndex.append(float(0)) #标点词向量设置为0 list ?
    #                wordIndex.append(listVal) #标点词向量设置为0 list ?
    #               wordSeq.append(listVal) #标点词向量设置为0 list ?
                elif ll.split('\t')[1] not in mapping.vocab:
                    for count in range(100) :
                        wordIndex.append(float(0)) #生僻或怪符号词向量设置为0 list ?
                else:
                    for x in mapping[ll.split('\t')[1]]:
                        wordIndex.append(x) #该词词向量
    #                wordIndex.append(mapping[ll.split('\t')[1]]) #该词词向量
   
                '''
                依存结构:该词孩子index+依存类型+孩子词向量
                '''
                flag = 0
                i = 0 
                for lll in lineData:
                    wordSeq = []                
                    if lll.split('\t')[6] == ll.split('\t')[0] and i< windowSize :
                        flag = 1
                        if lll.split('\t')[7] not in dictDep.keys() :
                            dictDep[lll.split('\t')[7]] = len(dictDep)
                        wordIndex.append(int(lll.split('\t')[0])) #孩子编号
                        wordIndex.append(dictDep.get(lll.split('\t')[7])) #孩子与当前词的依存关系类别
    #                    wordSeq.append(int(lll.split('\t')[0])) #孩子编号 
    #                    wordSeq.append(dictDep.get(lll.split('\t')[7])) #孩子与当前词的依存关系类别
                        if lll.split('\t')[7] == '标点符号' :
                            for count in range(100) :
                                wordIndex.append(float(0)) #标点词向量设置为0 list ?
    #                        wordIndex.append(listVal) #标点词向量设置为0 list ?
    #                        wordSeq.append(listVal) #标点词向量设置为0 list ?
                        elif lll.split('\t')[1] not in mapping.vocab:
                            for count in range(100) :
                                wordIndex.append(float(0)) #生僻或怪符号词向量设置为0 list ?
                        else:
                            for x in mapping[lll.split('\t')[1]] :
                                wordIndex.append(x) #该词词向量
    #                        wordIndex.append(mapping[lll.split('\t')[1]]) #孩子词向量
    #                        wordSeq.append(mapping[lll.split('\t')[1]]) #孩子词向量                    
    #                    wordIndex.append(wordSeq)
                        i+=1
                for count in range(102*(windowSize-i)):
                    wordIndex.append(float(0))
    #            if flag == 0 : #如果该词无孩子 则孩子序列则为0
    #                wordIndex.append(0)
                sentIndex.append(wordIndex) #注意!!依存句法结构提取出来第一词编号为1,而此处第一词编号 为 0 但index同 且提取出的孩子序号同原来编号      
                sentWord.append(ll.split('\t')[1])
        docIndex.append(sentIndex)
        allWord.append(sentWord)
    return docIndex,allWord
Esempio n. 39
0
        self.index = i
        self.obj = obj
        DestructionTracker.init_calls += 1
        tally[i] = 1
        super().__init__()

    def __del__(self):
        tally[self.index] += 1
        DestructionTracker.del_calls += 1

    def callback(self, message):
        pass


if __name__ == '__main__':
    jpype.startJVM(classpath=['test/classes', 'project/jpype_java/dist/*'],
                   convertStrings=True)

    print()
    kB = (1024 / 8)
    MB = (1024**2 / 8)

    fixture = JClass("jpype.common.Fixture")()
    for i in range(trials):
        x = np.arange(int(10 * kB), dtype=np.int64)

        interface = jpype.JProxy(
            "java.io.Serializable",
            dict={'callback': DestructionTracker(i, x).callback})
        interface_container = fixture.callObject(interface)

        if (i % 1000) == 0:
Esempio n. 40
0
            user = user.replace("\n", "")
        if impostazione == 'password':
            password = valore
            password = password.replace("\n", "")

##############################################FINE FILE INI IMPOSAZIONI###################################################################

#CONNESSIONE A SYBASE IQ
cnxn = pyodbc.connect("DSN=melc6h1_dmcomm")
cursiq = cnxn.cursor()
########FINE SYBASE IQ
#CONNESSIONE A DB2
jar = 'db2jcc4.jar'  # location of the jdbc driver jar
args = '-Djava.class.path=%s' % jar
jvm = jpype.getDefaultJVMPath()
jpype.startJVM(jvm, args)
jdbc_string = "jdbc:db2://" + server + ":" + porta + "/" + dbname
try:
    conn = jaydebeapi.connect("com.ibm.db2.jcc.DB2Driver", jdbc_string,
                              [user, password])  #connessione al db2
except:
    app = gui("MIGRAZIONE CLIENTI POTENZIALI SYBASE IQ -> DB2", "600x300")
    app.setBg("yellow")
    app.setFont(18)
    app.addLabel(
        "title",
        "\nCLIENTI POTENZIALI SYBASE IQ -> DB2\n")  #NOMELABEL, CONTENUTO
    app.setLabelBg("title", "blue")  #NOMELABEL, COLORE SFONDO
    app.setLabelFg("title", "red")  #NOME LABEL, COLORE CARATTERE
    app.addLabel("errore",
                 "!!!ERRORE CONNESSIONE A DB!!!")  #NOMELABEL, CONTENUTO
Esempio n. 41
0
# !/usr/local/bin/python3.7
# -*- coding: utf-8 -*-
# @Time  : 2019/10/15 17:37
# @Author: [email protected]
from jtyoui.neuralNetwork.paddle import ernie_st, ernie_match
from jpype import startJVM, JClass, getDefaultJVMPath
from config import Log, Models_DIR
import os
import jtyoui

HanNLP_path = os.path.dirname(__file__) + os.sep + 'hanlp-1.7.4.jar'
st = ernie_st(Models_DIR)
sep = ':' if os.name != 'nt' else ';'

# 开始初始化Java虚拟机
startJVM(getDefaultJVMPath(), F"-Djava.class.path={HanNLP_path}{sep}{os.path.dirname(__file__)}")
HanNLP = JClass('com.hankcs.hanlp.HanLP')


@jtyoui.log(Log)
def extract_summary(word, num=3):
    """摘要提取
    :param word:一段文字
    :param num: 提取的数量
    """
    result = HanNLP.extractSummary(word, num).toString()
    return result[1:-1]


@jtyoui.log(Log)
def extract_keyword(word, num=3):
tokenizer = TweetTokenizer()

from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer

import bokeh.plotting as bp
from bokeh.models import HoverTool, BoxSelectTool
from bokeh.plotting import figure, show, output_notebook

sg_flag = 0
tfidfflag = 1

# zemberek
import jpype

jpype.startJVM(jpype.getDefaultJVMPath(),
               "-Djava.class.path=zemberek_jar/zemberek-tum-2.0.jar", "-ea")
# Türkiye Türkçesine göre çözümlemek için gerekli sınıfı hazırla
Tr = jpype.JClass("net.zemberek.tr.yapi.TurkiyeTurkcesi")
# tr nesnesini oluştur
tr = Tr()
# Zemberek sınıfını yükle
Zemberek = jpype.JClass("net.zemberek.erisim.Zemberek")
# zemberek nesnesini oluştur
zemberek = Zemberek(tr)


def ingest():
    data = pd.read_csv("data/tweets_turktelekom_result.csv",
                       header=0,
                       delimiter="•",
                       quoting=3,
Esempio n. 43
0
# shutdownJVM()


def startJVM():
    # jvmPath = jpype.getDefaultJVMPath()
    jvmPath = u'D:\\Program Files\\Java\\jre1.8.0_152\\bin\server\\jvm.dll'
    jpype.startJVM(jvmPath)
    jpype.java.lang.System.out.println("hello world!")
    jpype.shutdownJVM()


# startJVM()

path = u'D:\\Program Files\\Java\\jre1.8.0_152\\bin\server\\jvm.dll'
# jvm.dll启动成功
jpype.startJVM(path, "-Djava.class.path=D:\\jupyter\\hanlp-portable-1.6.8.jar")

HanLP = JClass('com.hankcs.hanlp.HanLP')

# 中文分词
print(HanLP.segment('你好,欢迎在Python中调用HanLP的API'))
testCases = [
    "商品和服务", "结婚的和尚未结婚的确实在干扰分词啊", "买水果然后来世博园最后去世博会", "中国的首都是北京", "欢迎新老师生前来就餐",
    "工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作",
    "随着页游兴起到现在的页游繁盛,依赖于存档进行逻辑判断的设计减少了,但这块也不能完全忽略掉。"
]
for sentence in testCases:
    print(HanLP.segment(sentence))
# 命名实体识别与词性标注
NLPTokenizer = JClass('com.hankcs.hanlp.tokenizer.NLPTokenizer')
print(NLPTokenizer.segment('中国科学院计算技术研究所的宗成庆教授正在教授自然语言处理课程'))
Esempio n. 44
0
from database.database import database
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer
from snowballstemmer import stemmer
import json
import psycopg2 as psycopg2
from jpype import JClass, JString, getDefaultJVMPath, shutdownJVM, startJVM, java

ZEMBEREK_PATH = r'C:\Users\casper\PycharmProjects\title_generate\zemberek-full.jar'
startJVM(getDefaultJVMPath(),
         '-ea',
         f'-Djava.class.path={ZEMBEREK_PATH}',
         convertStrings=False)

db = database()
stopWords = set(stopwords.words('turkish'))
lemmatizer = WordNetLemmatizer()
stemmer = stemmer('turkish')


class preprocessing:
    def __init__(self):
        self.preprocess()

    def preprocess(self):

        sql = """ UPDATE texts_tab
                  SET pre_title = %s, pre_content = %s
                  WHERE id = %s"""
        conn = None
Esempio n. 45
0
def startJVM():
    # jvmPath = jpype.getDefaultJVMPath()
    jvmPath = u'D:\\Program Files\\Java\\jre1.8.0_152\\bin\server\\jvm.dll'
    jpype.startJVM(jvmPath)
    jpype.java.lang.System.out.println("hello world!")
    jpype.shutdownJVM()
Esempio n. 46
0
            input("Enter human reply delay 投入人工打回复延期(秒钟): "))

    #FIND WINDOW HANDLE
    try:
        regex = r".*(?= - 接待中心)"
        cW = QianNiuWindow()
        cW.find_window_regex(regex)
        cW.initialize()
        print(cW.userID, cW.msg_dlg, cW.input_dlg, cW.send_but)
    except:
        log_err("WINDOW HANDLE FIND")

    #START OCR & BOT
    projectDIR = os.getcwd()
    #set JAVA path
    defaultJVMpath = (r"C:\Program Files\Java\jdk-12.0.2\bin\server\jvm.dll")
    jarPath = "-Djava.class.path=" + os.path.join(projectDIR,
                                                  r"sikuliX\sikulixapi.jar")
    SeekImagePath = os.path.join(projectDIR, r"sikuliX\newmsg.PNG")

    print("Starting JVM...")
    jpype.startJVM(defaultJVMpath, '-ea', jarPath, convertStrings=False)
    jpype.java.lang.System.out.println("Started JVM!")

    bot = Chatbot()
    bot.start()

    #MAIN PROGRAMME LOOP
    print("Starting program....")
    main(cW, bot, SeekImagePath, mode, delay_time)
Esempio n. 47
0
#!/usr/bin/env python2.6
import jpype
from jpype import java
from jpype import javax

HOST = '192.168.90.50'
PORT = 9999
USER = '******'
PASS = '******'

URL = "service:jmx:rmi:///jndi/rmi://%s:%d/jmxrmi" % (HOST, PORT)
#this it the path of your libjvm /usr/lib/jvm/sun-jdk-1.6/jre/lib/amd64/server/libjvm.so on linux
jpype.startJVM(
    "/System/Library/Frameworks/JavaVM.framework/Libraries/libjvm_compat.dylib"
)
java.lang.System.out.println("JVM load OK")

jhash = java.util.HashMap()
jarray = jpype.JArray(java.lang.String)([USER, PASS])
jhash.put(javax.management.remote.JMXConnector.CREDENTIALS, jarray)
jmxurl = javax.management.remote.JMXServiceURL(URL)
jmxsoc = javax.management.remote.JMXConnectorFactory.connect(jmxurl, jhash)
connection = jmxsoc.getMBeanServerConnection()

object = "java.lang:type=Threading"
attribute = "ThreadCount"
attr = connection.getAttribute(javax.management.ObjectName(object), attribute)
print attribute, attr

#Memory is a special case the answer is a Treemap in a CompositeDataSupport
object = "java.lang:type=Memory"
Esempio n. 48
0
import jpype


jvmPath = jpype.getDefaultJVMPath()           #the path of jvm.dll
classpath = "/Users/moguoyi/pyStudy/httpApi/file"                 #the path of PasswordCipher.class
jvmArg = "-Djava.class.path=" + classpath
if not jpype.isJVMStarted():                    #test whether the JVM is started
    jpype.startJVM(jvmPath,jvmArg)             #start JVM
javaClass = jpype.JClass("Yit.class")   #create the Java class
ncryptedString = javaClass.moAdd(1,3)
print(ncryptedString)
jpype.shutdownJVM()        #shut down JVM
Esempio n. 49
0
sys.path.append(
    '/Users/jennyhung/MathfreakData/School/OMSCS_ML/Assign2/abagail_py/ABAGAIL/ABAGAIL.jar'
)
#print(sys.path)
from array import *
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
from itertools import product
#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.prob.GenericProbabilisticOptimizationProblem
jp.java.opt.RandomizedHillClimbing
jp.java.opt.prob.MIMIC
jp.java.opt.example.CountOnesEvaluationFunction
jp.java.func.nn.activation.RELU
Esempio n. 50
0
 def test_01(self):
     # 第二步:打开被测网站
     driver = self.driver
     driver.get(self.base_url)
     # 第三步:执行测试动作
     # 定义测试数据
     email = "*****@*****.**"
     password = "******"
     name = "王朝12001"
     # 登录主账号
     login_thinksns(driver, email, password, name)
     # 先定位到左侧应用列表,再点击 相册
     driver.find_element_by_class_name(
         "user_app_list").find_element_by_link_text("相册").click()
     # 得到当前照片数量 我的全部照片(2)
     number = self.get_pictures_number(driver, "我的全部照片(", ")")
     # 点击 上传
     driver.find_element_by_link_text("上传").click()
     sleep(1)
     # 定义jvm和sikuli jar包所在的路径
     jvm_path = r"C:\Program Files\Java\jdk1.8.0_151\jre\bin\server\jvm.dll"
     jar_path = "-Djava.class.path=" + self.path + r"\libs\sikulixapi.jar"
     # 启动JVM
     jpype.startJVM(jvm_path, jar_path)
     # 找到能够进行屏幕操作的Screen类(相当于将Java版本的Screen类转换成Python的)
     Screen = jpype.JClass("org.sikuli.script.Screen")
     # 实例化该Screen类
     screen = Screen()
     # 定义添加照片按钮图片所在的路径
     add_path = self.path + r"\images\sikuli_imgs\add.png"
     # 根据实例化对象,点击该图片
     screen.click(add_path)
     # 定义文件名输入框图片所在的路径
     input_path = self.path + r"\images\sikuli_imgs\input.png"
     # 根据实例化对象,点击该图片
     screen.click(input_path)
     # 定义两张需要上传的照片的路径 "c:\灯塔.jpg" "c:\八仙花.jpg"
     img1 = self.path + "\\images\\blog_imgs\\" + str(randint(0,
                                                              7)) + ".jpg"
     img2 = self.path + "\\images\\blog_imgs\\" + str(randint(0,
                                                              7)) + ".jpg"
     img_path = '"' + img1 + '" "' + img2 + '"'
     # 根据实例化对象,在输入框内输入上述路径
     screen.type(input_path, img_path)
     # 定义打开按钮的图片所在的路径
     open_path = self.path + r"\images\sikuli_imgs\open.png"
     # 根据实例化对象,点击该图片
     screen.click(open_path)
     sleep(1)
     # 关闭JVM
     jpype.shutdownJVM()
     # 点击开始上传
     driver.find_element_by_id("btnUpload").click()
     sleep(2)
     # 判断是否出现成功的提示,判断在其中即可: 照片上传成功!
     actual_tip = driver.find_element_by_name("save_upload_photos").text
     self.assertIn("照片上传成功!", actual_tip)
     # 点击完成上传
     driver.find_element_by_class_name("btn_b").click()
     # 得到当前照片数量 共4张
     actual_number = self.get_pictures_number(driver, "共", "张")
     # 判断照片数量的变化是否正确
     self.assertEqual(number + 2, actual_number)
Esempio n. 51
0
    def __init__(self,
                 filename,
                 meta=True,
                 java_memory='512m',
                 read_mode='auto',
                 series=0):
        global loci

        if read_mode not in ['auto', 'jpype', 'stringbuffer', 'javacasting']:
            raise ValueError('Invalid read_mode value.')

        # Make sure that file exists before starting java
        if not os.path.isfile(filename):
            raise IOError('The file "{}" does not exist.'.format(filename))

        # Start java VM and initialize logger (globally)
        if not jpype.isJVMStarted():
            loci_path = _find_jar()
            jpype.startJVM(jpype.getDefaultJVMPath(), '-ea',
                           '-Djava.class.path=' + loci_path,
                           '-Xmx' + java_memory)
            log4j = jpype.JPackage('org.apache.log4j')
            log4j.BasicConfigurator.configure()
            log4j_logger = log4j.Logger.getRootLogger()
            log4j_logger.setLevel(log4j.Level.ERROR)

        if not jpype.isThreadAttachedToJVM():
            jpype.attachThreadToJVM()

        loci = jpype.JPackage('loci')

        # Initialize reader and metadata
        self.filename = str(filename)
        self.rdr = loci.formats.ChannelSeparator(loci.formats.ChannelFiller())
        if meta:
            self._metadata = loci.formats.MetadataTools.createOMEXMLMetadata()
            self.rdr.setMetadataStore(self._metadata)
        self.rdr.setId(self.filename)
        if meta:
            self.metadata = MetadataRetrieve(self._metadata)

        # Checkout reader dtype and define read mode
        isLittleEndian = self.rdr.isLittleEndian()
        LE_prefix = ['>', '<'][isLittleEndian]
        FormatTools = loci.formats.FormatTools
        self._dtype_dict = {
            FormatTools.INT8: 'i1',
            FormatTools.UINT8: 'u1',
            FormatTools.INT16: LE_prefix + 'i2',
            FormatTools.UINT16: LE_prefix + 'u2',
            FormatTools.INT32: LE_prefix + 'i4',
            FormatTools.UINT32: LE_prefix + 'u4',
            FormatTools.FLOAT: LE_prefix + 'f4',
            FormatTools.DOUBLE: LE_prefix + 'f8'
        }
        self._dtype_dict_java = {}
        for loci_format in self._dtype_dict.keys():
            self._dtype_dict_java[loci_format] = \
                (FormatTools.getBytesPerPixel(loci_format),
                 FormatTools.isFloatingPoint(loci_format),
                 isLittleEndian)

        # Set the correct series and initialize the sizes
        self.size_series = self.rdr.getSeriesCount()
        if series >= self.size_series or series < 0:
            self.rdr.close()
            raise IndexError('Series index out of bounds.')
        self._series = series
        self._change_series()

        # Set read mode. When auto, tryout fast and check the image size.
        if read_mode == 'auto':
            Jarr = self.rdr.openBytes(0)
            if isinstance(Jarr[:], np.ndarray):
                read_mode = 'jpype'
            else:
                warn('Due to an issue with JPype 0.6.0, reading is slower. '
                     'Please consider upgrading JPype to 0.6.1 or later.')
                try:
                    im = self._jbytearr_stringbuffer(Jarr)
                    im.reshape(self._sizeRGB, self._sizeX, self._sizeY)
                except (AttributeError, ValueError):
                    read_mode = 'javacasting'
                else:
                    read_mode = 'stringbuffer'
        self.read_mode = read_mode

        # Define the names of the standard per frame metadata.
        self.frame_metadata = {}
        if meta:
            if hasattr(self.metadata, 'PlaneDeltaT'):
                self.frame_metadata['t_s'] = 'PlaneDeltaT'
            if hasattr(self.metadata, 'PlanePositionX'):
                self.frame_metadata['x_um'] = 'PlanePositionX'
            if hasattr(self.metadata, 'PlanePositionY'):
                self.frame_metadata['y_um'] = 'PlanePositionY'
            if hasattr(self.metadata, 'PlanePositionZ'):
                self.frame_metadata['z_um'] = 'PlanePositionZ'
Esempio n. 52
0
# To change this license header, choose License Headers in Project Properties.
# To change this template file, choose Tools | Templates
# and open the template in the editor.

#if __name__ == "__main__":
#    print "Hello World"

from WorkingWithFiles import ConvertingWorksheetToSVG
import jpype
import os.path

asposeapispath = os.path.join(os.path.abspath("../../../"), "lib/")
dataDir = os.path.join(os.path.abspath("./"), "data/")

print "You need to put your Aspose.Cells for Java APIs .jars in this folder:\n" + asposeapispath

#print dataDir
jpype.startJVM(jpype.getDefaultJVMPath(),
               "-Djava.ext.dirs=%s" % asposeapispath)

hw = ConvertingWorksheetToSVG(dataDir)
hw.main()
Esempio n. 53
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@time: 2021/1/31 10:36
@author: LQ
@email: [email protected]
@File: jvm_tool.py
@Software: PyCharm
"""

import jpype
import os

base_dir = os.path.dirname(os.path.abspath(__file__))

jarpath = os.path.join(base_dir, "java-utils.jar")  # 第二个参数是jar包的路径
jpype.startJVM(jpype.getDefaultJVMPath(), "-ea",
               "-Djava.class.path=%s" % (jarpath))  # 启动jvm
JDClass = jpype.JClass("com.demo.utils.PakoGzipUtils")
jpython_obj = JDClass()  # 创建类的实例,可以调用类里边的方法

if __name__ == '__main__':
    jpype.shutdownJVM()  # 最后关闭jvm
Esempio n. 54
0

ERRORCONNECTIONTITLE = U"Fehler beim Verbindungsaufbau"


ConTypes = Enum("Eibnet", "sFT12")
ConTypesText = Enum("Eibnet/IP", "RS232 FT1.2")
COM = Enum("COM 1", "COM 2", "COM 3", "COM 4", "COM 5", "COM 6", "COM 7", "COM 8")

#-----------------------------------------------------------------------------------------------------------------------
#---------------------------------------------  Java Kram --------------------------------------------------------------
#-----------------------------------------------------------------------------------------------------------------------
#Get path to directory with calimero-2.0a4.jar
jarpath = os.path.join(os.path.abspath("."), "lib")
#Start JVM
jpype.startJVM(jpype.getDefaultJVMPath(), "-Djava.ext.dirs=%s" % jarpath)


KNXNetworkLinkIP = jpype.JClass("tuwien.auto.calimero.link.KNXNetworkLinkIP")
TPSettings = jpype.JClass("tuwien.auto.calimero.link.medium.TPSettings")
KNXnetIPTunnel = jpype.JClass("tuwien.auto.calimero.knxnetip.KNXnetIPTunnel")
CEMILData = jpype.JClass("tuwien.auto.calimero.cemi.CEMILData")
IndividualAddress = jpype.JClass("tuwien.auto.calimero.IndividualAddress")
KNXAddress = jpype.JClass("tuwien.auto.calimero.KNXAddress")
ManagementClientImpl = jpype.JClass("tuwien.auto.calimero.mgmt.ManagementClientImpl")

#java internals
KNXnetIPConnection = jpype.JClass("tuwien.auto.calimero.knxnetip.KNXnetIPConnection")
InetSocketAddress = jpype.JClass("java.net.InetSocketAddress")

#interfaces
Esempio n. 55
0
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)
Esempio n. 56
0
import os

import jpype


jpype.startJVM(jpype.getDefaultJVMPath(),"-ea","-Djava.class.path=c:/Java")

A = jpype.JClass("C")
c = A()

c.a()

jpype.shutdownJVM()
str_NATS_CLIENT_HOME = ""

if not (env_NATS_CLIENT_HOME is None):
    str_NATS_CLIENT_HOME = env_NATS_CLIENT_HOME + "/"

classpath = str_NATS_CLIENT_HOME + "dist/nats-client.jar"
classpath = classpath + ":" + str_NATS_CLIENT_HOME + "dist/nats-shared.jar"
classpath = classpath + ":" + str_NATS_CLIENT_HOME + "dist/json.jar"
classpath = classpath + ":" + str_NATS_CLIENT_HOME + "dist/rmiio-2.1.2.jar"
classpath = classpath + ":" + str_NATS_CLIENT_HOME + "dist/commons-logging-1.2.jar"

#b directory in which Center and Sector data are located
data_dir = './data'

#starts JVM
jp.startJVM(jp.getDefaultJVMPath(), "-ea", "-Djava.class.path=%s" % classpath)

NATSClientFactory = jp.JClass('NATSClientFactory')
natsClient = NATSClientFactory.getNATSClient()

#Obtain the airport for the above aircraft
environmentInterface = natsClient.getEnvironmentInterface()
airportInterface = environmentInterface.getAirportInterface()

natsClient.login("admin")

# =============================================================================

# TaxiPlan Design Example starts here
#
# Step 1. Load TRX file and select an aircraft.
Esempio n. 58
0
def init_jvm(jvmpath):
    if jpype.isJVMStarted():
        return
    jpype.startJVM(classpath=[jvmpath])
# coding: utf-8

# In[3]:


from jpype import JClass, JString, getDefaultJVMPath, shutdownJVM, startJVM


# In[5]:


startJVM(
    getDefaultJVMPath(),
    '-ea',
    '-Djava.class.path=zemberek-full.jar',
    convertStrings=False
)


# In[6]:


Paths: JClass = JClass('java.nio.file.Paths')


# In[39]:


trainPath = Paths.get("./enamex_train.txt")
testPath = Paths.get("./enamex_test.txt")
Esempio n. 60
-1
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()}