def init(self, config: Config): """ if `config.microrts_path` is set, then the script will automatically try to launch a microrts client instance. Otherwise you need to set the `config.height` and `config.this script will just wait to listen to the microrts client """ self.config = config root = ET.parse( os.path.expanduser( os.path.join(self.config.microrts_path, self.config.map_path))).getroot() self.config.height, self.config.width = int(root.get("height")), int( root.get("width")) self.running_first_episode = True self.closed = False # Launch the JVM if not jpype._jpype.isStarted(): registerDomain("ts", alias="tests") registerDomain("ai") jpype.addClassPath( os.path.expanduser( os.path.join(self.config.microrts_path, "microrts.jar"))) jpype.startJVM(convertStrings=False) self.client = self.start_client() # computed properties self.init_properties()
def generate(content, engine, name): #dir_name,uuidx = Util.set_dir() dir_tmp = tempfile.TemporaryDirectory() uuidx = uuid.uuid4().__str__() dir_name = dir_tmp.name swagger_file_path = os.path.join(dir_name, uuidx) swagger_file = open(swagger_file_path, "w+") swagger_file.write(content) swagger_file.close() #startJVM(getDefaultJVMPath(),"-ea", "-Djava.class.path=halo-flask-openapi-generator.jar;openapi-generator-cli.jar") if not jpype.isJVMStarted(): #@todo make sure running directory is project root jars_dir = os.path.join(settings.BASE_DIR, '..', 'jars') jars_path = jars_dir + '/*' #jar_dir = os.path.join(os.getcwd(), 'jars') print("starting jvm:" + jars_path) startJVM("-ea", classpath=[jars_path], convertStrings=False) print(java.lang.System.getProperty('java.class.path')) addClassPath("org/openapitools/codegen") #from org.openapitools.codegen import OpenAPIGenerator jpype.JClass("org.openapitools.codegen.OpenAPIGenerator").main([ 'generate', '-g', engine, '-i', swagger_file_path, "-o", dir_name, "--package-name", name ]) print("finished generate") return Util.build_result(dir_name, name)
def startJVM(): jars = os.path.join(os.path.dirname(os.path.realpath(__file__)), "libs") classpath = f'{str.join(os.pathsep, [os.path.join(jars, entry) for entry in os.listdir(jars)])}' if not jpype.isJVMStarted(): jpype.startJVM(classpath = classpath) else: jpype.addClassPath(classpath)
def __init__(self): self.pdfbox_path = self._get_pdfbox_path() jpype.addClassPath(self.pdfbox_path) if not jpype.isJVMStarted(): jpype.startJVM(convertStrings=False) import org.apache.pdfbox.tools as tools self.pdfbox_tools = tools
def add_jar_class_path(self, dir_or_jar): try: if os.path.isdir(dir_or_jar): jpype.addClassPath(os.path.join(dir_or_jar, "*")) elif os.path.splitext(dir_or_jar)[-1] == '.jar': jpype.addClassPath(dir_or_jar) except Exception as ex: raise NameError("Error adding class path: {}".format(ex))
def startJVM(self): jpype.addClassPath( 'HWdevices/PSI_java/lib/jar/bioreactor-commander-0.8.7.jar') jpype.startJVM( jvmpath=jpype.getDefaultJVMPath(), convertStrings=False, classpath= "HWdevices/PSI_java/lib/jar/bioreactor-commander-0.8.7.jar")
def setUp(self): root = path.dirname(path.abspath(path.dirname(__file__))) jpype.addClassPath(path.join(root, 'classes')) jvm_path = jpype.getDefaultJVMPath() classpath_arg = "-Djava.class.path=%s" classpath_arg %= jpype.getClassPath() jpype.startJVM(jvm_path, "-ea", # "-Xcheck:jni", "-Xmx256M", "-Xms16M", classpath_arg)
def __init__(self,server="127.0.0.1:11222"): dir = os.path.dirname(os.path.abspath(__file__)) classpath=dir+"/java/*" jpype.addClassPath(classpath) startJVM(getDefaultJVMPath(), "-ea", convertStrings=False) self.Package = JPackage("org.crucial.dso") self.client = self.Package.client.Client.getClient(server)
def initialize_java_vm(class_path=None): if not jpype.isJVMStarted(): try: if class_path: jpype.addClassPath(class_path) jpype.startJVM(convertStrings=False) except TypeError as ex: print("TypeError raised: {}.".format(ex)) except OSError as ex: print("OSError raised: {}.".format(ex))
def testAddClassPath(self): import pathlib import org.jpype as ojp self.assertFalse("late" in dir(ojp)) with self.assertRaises(ImportError): import org.jpype.late as late jpype.addClassPath(pathlib.Path("test/jar/late/late.jar").absolute()) import org.jpype.late as late self.assertTrue("Test" in dir(late)) t = late.Test() self.assertTrue(t.field == 5) self.assertTrue(t.method() == "Yes")
def run_jar(project_folder: str, get_features_jar: str, jvm_path: Optional[str] = None): """调用 getFeatures.jar 生成 features.csv, comments.csv, link.csv""" if jvm_path is None: jvm_path = jpype.getDefaultJVMPath() abs_jar_path = os.path.abspath(get_features_jar) jpype.startJVM(jvm_path, '-ea', f'-Djava.class.path={abs_jar_path}') jpype.addClassPath(abs_jar_path) # 手动添加 classpath java_class = jpype.JClass('com.tcl.App') abs_proj_path = os.path.abspath(project_folder) java_class.getFeatures(abs_proj_path) java_class.getComments(abs_proj_path) jpype.shutdownJVM()
def start_jvm(self): self.lock.acquire() if not self.is_jvm_started(): jpype.addClassPath( 'custom/devices/PSI/java/lib/jar/bioreactor-commander-0.8.7.jar' ) jpype.startJVM( jvmpath=jpype.getDefaultJVMPath(), convertStrings=False, classpath= "custom/devices/PSI/java/lib/jar/bioreactor-commander-0.8.7.jar" ) self.lock.release()
def setUp(self): if not jpype.isJVMStarted(): root = path.dirname(path.abspath(path.dirname(__file__))) jpype.addClassPath(path.join(root, 'classes')) jvm_path = jpype.getDefaultJVMPath() logger = logging.getLogger(__name__) logger.info("Running testsuite using JVM %s" % jvm_path) classpath_arg = "-Djava.class.path=%s" classpath_arg %= jpype.getClassPath() jpype.startJVM(jvm_path, "-ea", # "-Xcheck:jni", "-Xmx256M", "-Xms16M", classpath_arg) self.jpype = jpype.JPackage('jpype') if sys.version < '3': self.assertCountEqual = self.assertItemsEqual
def setUp(self): if not jpype.isJVMStarted(): root = path.dirname(path.abspath(path.dirname(__file__))) jpype.addClassPath(path.join(root, 'classes')) jvm_path = jpype.getDefaultJVMPath() logger = logging.getLogger(__name__) logger.info("Running testsuite using JVM %s" % jvm_path) classpath_arg = "-Djava.class.path=%s" classpath_arg %= jpype.getClassPath() jpype.startJVM(jvm_path, "-ea", # "-Xcheck:jni", "-Xmx256M", "-Xms16M", classpath_arg) self.jpype = jpype.JPackage('jpype') if sys.version < '3': self.assertCountEqual = self.assertItemsEqual
def __init__(self, path_reframeLib_jar: str = r'jar/reframeLib.jar', path_jvm_dll: str = r''): self._path_lib = path_reframeLib_jar self._path_jvm = path_jvm_dll self._lib = None jpype.addClassPath(_get_path(self._path_lib)) if self._path_jvm == '' and not jpype.isJVMStarted(): jpype.startJVM(jpype.getDefaultJVMPath(), "-ea", convertStrings=False) elif not jpype.isJVMStarted(): jpype.startJVM(self._path_jvm, "-ea", convertStrings=False) javaPackage = jpype.JPackage('com.swisstopo.geodesy.reframe_lib') jReframe = jpype.JClass('com.swisstopo.geodesy.reframe_lib.Reframe') jPlanimetricFrame = javaPackage.IReframe.PlanimetricFrame jAltimetricFrame = javaPackage.IReframe.AltimetricFrame jProjectionChange = javaPackage.IReframe.ProjectionChange self._lib = jReframe() self.planimetric_frames = { 'lv95': jPlanimetricFrame.LV95, 'lv03_military': jPlanimetricFrame.LV03_Military, 'lv03_civil': jPlanimetricFrame.LV03_Civil } self.altimetric_frames = { 'lhn95': jAltimetricFrame.LHN95, 'ln02': jAltimetricFrame.LN02, 'ellipsoid': jAltimetricFrame.Ellipsoid } self.projection_changes = { 'etrf93_geocentric_to_lv95': jProjectionChange.ETRF93GeocentricToLV95, 'etrf93_gepgraphic_to_lv95': jProjectionChange.ETRF93GeographicToLV95, 'lv95_to_etrf93_geocentric': jProjectionChange.LV95ToETRF93Geocentric, 'lv95_to_etrf93_geographic': jProjectionChange.LV95ToETRF93Geographic }
def start_jvm(self): """ Start Java virtual machine. """ self.lock.acquire() if not self.is_jvm_started(): jpype.addClassPath( 'app/workspace/devices/PSI/java/lib/jar/bioreactor-commander-0.8.7.jar' ) jpype.startJVM( jvmpath=jpype.getDefaultJVMPath(), convertStrings=False, classpath= "app/workspace/devices/PSI/java/lib/jar/bioreactor-commander-0.8.7.jar" ) self.lock.release()
def setUp(self): if not jpype.isJVMStarted(): root = path.dirname(path.abspath(path.dirname(__file__))) jpype.addClassPath(path.join(root, 'classes')) jvm_path = jpype.getDefaultJVMPath() logger = logging.getLogger(__name__) logger.info("Running testsuite using JVM %s" % jvm_path) classpath_arg = "-Djava.class.path=%s" classpath_arg %= jpype.getClassPath() JPypeTestCase.str_conversion = eval(os.getenv('JPYPE_STR_CONVERSION', 'True')) jpype.startJVM(jvm_path, "-ea", # TODO: enabling this check crashes the JVM with: FATAL ERROR in native method: Bad global or local ref passed to JNI #"-Xcheck:jni", "-Xmx256M", "-Xms16M", classpath_arg, convertStrings=self.str_conversion) self.jpype = jpype.JPackage('jpype') if sys.version < '3': self.assertCountEqual = self.assertItemsEqual
def build_and_start_jvm(self, maven_dir: str, code_dir: str, root_package: str, jvm_path=None): # Needs to be done here to work with setuptools setup_requires # (otherwise imported before that line is even read) import jpype if jvm_path is None: jvm_path = jpype.get_default_jvm_path() _logger.debug('generating classpath in {}'.format(maven_dir)) pom_path = os.path.join(maven_dir, 'pom.xml') self._generate_full_pom(pom_path) maven_completion = subprocess.run( ['mvn', '-DskipTests=true', 'assembly:assembly'], cwd=maven_dir) maven_completion.check_returncode() for jar in os.listdir(os.path.join(maven_dir, 'target')): if jar.endswith('jar-with-dependencies.jar'): full_path = os.path.join(maven_dir, 'target', jar) _logger.debug('adding {} to classpath'.format(full_path)) jpype.addClassPath(full_path) jpype.startJVM(jvm_path, "-Djava.class.path=%s" % jpype.getClassPath(), convertStrings=False) # TODO: generate pxi files for all classes on classpath. Needs to be done after build # - generate python type-hinted classes # - store them next to jar # - put them on sys.path PyiUtils = jpype.JClass( 'org.matsim.contrib.pythonmatsim.typehints.PyiUtils') try: PyiUtils.generatePythonWrappers(code_dir, root_package) except jpype.JException as e: print(e.message()) print(e.stacktrace()) raise e _logger.debug('done generating classpath')
def setUp(self): if not jpype.isJVMStarted(): try: import faulthandler faulthandler.enable() faulthandler.disable() except: pass root = path.dirname(path.abspath(path.dirname(__file__))) jpype.addClassPath(path.join(root, 'classes')) jvm_path = jpype.getDefaultJVMPath() logger = logging.getLogger(__name__) logger.info("Running testsuite using JVM %s" % jvm_path) classpath_arg = "-Djava.class.path=%s" args = ["-ea", "-Xmx256M", "-Xms16M"] if self._checkjni: args.append("-Xcheck:jni") # TODO: enabling this check crashes the JVM with: FATAL ERROR in native method: Bad global or local ref passed to JNI # "-Xcheck:jni", if self._classpath: from pathlib import Path import warnings # This needs to be relative to run location jpype.addClassPath(Path(self._classpath).resolve()) warnings.warn("using jar instead of thunks") if self._convertStrings: import warnings warnings.warn("using deprecated convertStrings") if self._jacoco: import warnings args.append( "-javaagent:project/coverage/org.jacoco.agent-0.8.5-runtime.jar=destfile=build/coverage/jacoco.exec,includes=org.jpype.*" ) warnings.warn("using JaCoCo") classpath_arg %= jpype.getClassPath() args.append(classpath_arg) _jpype.enableStacktraces(True) #JPypeTestCase.str_conversion = eval(os.getenv('JPYPE_STR_CONVERSION', 'True')) jpype.startJVM(jvm_path, *args, convertStrings=self._convertStrings) self.jpype = jpype.JPackage('jpype') if sys.version < '3': self.assertCountEqual = self.assertItemsEqual
def __init__(self): jar_path = Path(__file__).parent / "hartree" found_jars = sorted(jar_path.glob('*.jar')) if len(found_jars) == 0: raise Exception( "Could not find any JARs in dir {}".format(jar_path)) for found_jar in found_jars: jpype.addClassPath(found_jar) print("Classpath: ", jpype.getClassPath()) jpype.startJVM(convertStrings=False) # TODO: Figure out how to scope these imports for the class # noinspection PyUnresolvedReferences from org.cmayes.hartree.loader.gaussian import SnapshotLoader self.loader = SnapshotLoader()
def start_jvm(jvm_path=jpype.get_default_jvm_path(), *additional_classpath): if not pkg_resources.resource_exists('javaresources', 'python-matsim-instance-1.0-SNAPSHOT-jar-with-dependencies.jar'): raise RuntimeError('could not find jar file') if jpype.isJVMStarted(): # TODO: check that classpath etc. are the ones we want _logger.info("JVM is already live, do nothing.") return python_matsim_jar = pkg_resources.resource_filename('javaresources', 'python-matsim-instance-1.0-SNAPSHOT-jar-with-dependencies.jar') jpype.addClassPath(python_matsim_jar) for jar in additional_classpath: jpype.addClassPath(jar) _logger.info('start jvm with classpath {}'.format(jpype.getClassPath())) jpype.startJVM(jvm_path, "-Djava.class.path=%s" % jpype.getClassPath(), convertStrings=False)
def generateGraph(self, extractionQuery, filename, serialization_format='gml'): graphmk_version = '1.0.0' if jpype.isJVMStarted() != True: classpth = os.path.dirname(os.path.abspath( __file__)) + "/lib/graphmk-{0}.jar".format(graphmk_version) jpype.startJVM(jpype.getDefaultJVMPath()) jpype.addClassPath(classpth) GraphGenerateClass = jpype.JClass( 'io.github.graphmk.graphcore.PyGenerateGraph') GraphGenerateClass.main([ extractionQuery, serialization_format, filename, self.host, self.port, self.dbname, self.username, self.password ]) return filename + "." + serialization_format
def load(jvmPath=None): complete = "" if jvmPath == None: complete = jpype.getDefaultJVMPath() else: linux = os.path.join(jvmPath, "lib", "server", "libjvm.so") win = os.path.join(jvmPath, "bin", "server", "jvm.dll") mac = os.path.join(jvmPath, "lib", "server", "libjvm.dylib") if os.path.exists(linux): complete = linux elif os.path.exists(win): complete = win elif os.path.exists(mac): complete = mac # Link in JISA.jar classes jpype.addClassPath(os.path.join(path, "JISA.jar")) jpype.imports.registerDomain("jisa") # Start the JVM jpype.startJVM(jvmpath=complete, convertStrings=True)
def __init__(self, render_theme=2, frame_skip=0, ai2=microrts_ai.passiveAI, map_path="maps/10x10/basesTwoWorkers10x10.xml"): self.render_theme = render_theme self.frame_skip = frame_skip self.ai2 = ai2 self.map_path = map_path self.microrts_path = os.path.join(gym_microrts.__path__[0], 'microrts') root = ET.parse(os.path.join(self.microrts_path, self.map_path)).getroot() self.height, self.width = int(root.get("height")), int( root.get("width")) # Launch the JVM if not jpype._jpype.isStarted(): registerDomain("ts", alias="tests") registerDomain("ai") jpype.addClassPath(os.path.join(self.microrts_path, "microrts.jar")) jpype.addClassPath(os.path.join(self.microrts_path, "Coac.jar")) jpype.startJVM(convertStrings=False) from rts.units import UnitTypeTable self.real_utt = UnitTypeTable() self.client = self.start_client() self.client.renderTheme = self.render_theme # get the unit type table self.utt = json.loads(str(self.client.sendUTT())) # computed properties self.init_properties()
def testCygwin(self): if sys.platform == "win32" or sys.platform == "cygwin": raise common.unittest.SkipTest("not tested on cygwin") try: sys.platform = "cygwin" importlib.reload(jpype._classpath) self.assertEqual(jpype._classpath._SEP, ";") self.assertEqual(jpype._classpath._root, None) jpype._classpath._root = r'C:\cygwin64' self.assertEqual(jpype._classpath._get_root(), r'C:\cygwin64') self.assertEqual( jpype._classpath._splitpath('/cygdrive/c/cygwin64'), ['cygdrive', 'c', 'cygwin64']) self.assertEqual( jpype._classpath._posix2win('/cygdrive/c/windows'), 'c:\\windows') self.assertEqual(jpype._classpath._posix2win('/bin'), r"C:\cygwin64\bin") jpype._classpath._CLASSPATHS = [] jpype.addClassPath("/cygdrive/c/windows") jpype.addClassPath("/cygdrive/c/data") self.assertEqual(jpype._classpath._CLASSPATHS, [r"c:\windows", r"c:\data"]) env = os.environ.get("CLASSPATH") os.environ["CLASSPATH"] = r"c:\programs" self.assertEqual(jpype.getClassPath(True), r"c:\windows;c:\data;c:\programs") self.assertEqual(jpype.getClassPath(False), r"c:\windows;c:\data") # jpype.addClassPath("") #self.assertEqual(jpype.getClassPath(False), r"c:\windows;c:\data") jpype.addClassPath("/cygdrive/c/data/*") self.assertEqual(jpype.getClassPath(False), r"c:\windows;c:\data") if not env: del os.environ["CLASSPATH"] jpype._classpath._CLASSPATHS = [] with self.assertRaises(jpype.JVMNotFoundException): jpype.getDefaultJVMPath() finally: sys.platform = self.platform importlib.reload(jpype._classpath)
import os import imp import jpype import jpype.imports from jpype.types import * if jpype.isJVMStarted() != True: jars = [] for top, dirs, files in os.walk( imp.find_module('pdfextract')[1] + '/data'): for nm in files: if nm[-4:] == ".jar": jars.append(os.path.join(top, nm)) jpype.addClassPath(os.pathsep.join(jars)) jpype.startJVM(jpype.getDefaultJVMPath(), convertStrings=False) from java.lang import System from java.io import PrintStream, File System.setOut(PrintStream(File(os.devnull)))
This file summarizes all java accessm dask_sql needs. The jpype package is used to access Java classes from python. It needs to know the java class path, which is set to the jar file in the package resources. """ import pkg_resources import logging import jpype logger = logging.getLogger(__name__) # Define how to run the java virtual machine. jpype.addClassPath(pkg_resources.resource_filename("dask_sql", "jar/DaskSQL.jar")) # There seems to be a bug on Windows server for java >= 11 installed via conda # It uses a wrong java class path, which can be easily recognizes # by the \\bin\\bin part. We fix this here. jvmpath = jpype.getDefaultJVMPath() jvmpath = jvmpath.replace("\\bin\\bin\\server\\jvm.dll", "\\bin\\server\\jvm.dll") logger.debug(f"Starting JVM from path {jvmpath}...") jpype.startJVM( "-ea", "--illegal-access=deny", ignoreUnrecognized=True, convertStrings=False, jvmpath=jvmpath, )
# 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/. name = "pypowsybl_open_loadflow" import os import jpype mypath = os.path.dirname(__file__) POWSYBL_OPENLOADFLOW_LIBRARIES_PATH = os.path.join(mypath, 'jars') POWSYBL_OPENLOADFLOW_LIBRARIES = "{}/*".format(POWSYBL_OPENLOADFLOW_LIBRARIES_PATH) jpype.addClassPath(POWSYBL_OPENLOADFLOW_LIBRARIES)
def main(): # Parse arguments import argparse parser = argparse.ArgumentParser(description='Runs a bayesian optimisation for some of the algorithms defined in the PTSP framework') parser.add_argument('--algorithm', choices=["QD-MCTS", "S-MCTS", "MS-MCTS", "VanillaGA", "VanillaMCTS"], help='The algorithm that should be optimized', default="S-MCTS") parser.add_argument('--outputDir', default="./optimizationResults", help='The output directory for all data generated by the optimization') parser.add_argument("--ptspPath", default="./ptsp.jar", help="The path to the .jar file containing the PTSP framework") parser.add_argument("--iters", default="10", type=int, help="Number of parameter-points to test by the bayesian optimization") args = parser.parse_args() args.outputPath = f"{args.outputDir}/{args.algorithm}" # Find all previous logs for this optimization logs = glob.glob(f"{args.outputPath}/optimizationLogs*.json") csvLogs = glob.glob(f"{args.outputPath}/*.csv") # Launch the JVM jpype.startJVM() jpype.addClassPath(args.ptspPath) import framework.Optimization as optim # Move java output into a file from java.lang import System from java.io import PrintStream, FileOutputStream pathlib.Path(args.outputPath).mkdir(parents=True, exist_ok=True) System.setOut(PrintStream(FileOutputStream(f"{args.outputPath}/cout.txt", True))) # Algorithm specific data bounds = { "QD-MCTS" : { "lowER": (0.01, 10), # Exploration rate low-level search "highER": (0.01, 10), # Exploration rate high-level search "steps": (300, 600), # Number of steps for low-level search "rd": (10, 30) # rolloutDepth }, "S-MCTS" : { "cellSize": (5, 30), # Size of a cell in the subgoal grid (aka distance between subgoals) "er": (0.01, 10), # Exploration rate high-level search "steps": (300, 600), # Number of steps for low-level search "rd": (10, 30) # rolloutDepth }, "MS-MCTS" : { "cellSize": (5, 30), # Size of a cell in the subgoal grid (aka distance between subgoals) "er": (0.01, 10), # Exploration rate high-level search "steps": (300, 600), # Number of steps for low-level search "rd": (10, 30) # rolloutDepth }, "VanillaGA" : { "gl": (10, 30), # How many base-actions does a genome contain "ps": (1, 100), # How many genomes in one population "mr": (0.1, 0.9), # Probability that an action is mutated }, "VanillaMCTS" : { "er": (0.01, 10), # Exploration rate "rd": (10, 30), # RolloutDepth } } funcs = { "QD-MCTS" : lambda lowER, highER, steps, rd: execSafe(optim.runQD_MCTS, lowER, highER, round(steps), round(rd)), "S-MCTS" : lambda cellSize, er, steps, rd: execSafe(optim.runSMCTS, cellSize, er, round(steps), round(rd)), "MS-MCTS" : lambda cellSize, er, steps, rd: execSafe(optim.runMS_MCTS, cellSize, er, round(steps), round(rd)), "VanillaGA" : lambda gl, ps, mr: execSafe(optim.runVanillaGA, round(gl), round(ps), mr), "VanillaMCTS" : lambda er, rd: execSafe(optim.runVanillaMCTS, er, round(rd)) } # Probe points for each algorithm, only one which I've used previously probes = { "QD-MCTS" : {"lowER": math.sqrt(2), "highER": 4, "steps": 400, "rd": 25}, "S-MCTS" : {"cellSize": 20, "er": 4, "steps": 400, "rd": 25}, "MS-MCTS" : {"cellSize": 20, "er": 4, "steps": 400, "rd": 25}, "VanillaGA" : {"gl": 20, "ps": 50, "mr": 1. / 20}, "VanillaMCTS" : {"er": math.sqrt(2), "rd": 12} } # Initialize optimization optim.setupRun(len(logs) * 11) # Different seed for each run optim.RUN_COUNTER = len(csvLogs) # Make sure java logs into a new csv file optim.NUM_TRIALS = 10 optim.OutputDir = args.outputPath optim.m_mapNames = glob.glob("./maps/**/*.map", recursive=True) optimizer = BayesianOptimization( f=funcs[args.algorithm], pbounds=bounds[args.algorithm], random_state=len(logs) * 11, # Change behaviour for each run ) print(f"Optimizing {args.algorithm} with bounds:") print(bounds[args.algorithm]) # Probe if necessary init_points = 0 if len(logs) == 0: print("Found no previous logs... Probing to improve results:") print(probes[args.algorithm]) optimizer.probe(params=probes[args.algorithm], lazy=True) init_points = 5 else: # If we found logs, load them print(f"Reading previous logs into optimizer...") load_logs(optimizer, logs=logs); for log in logs: print(f"Successfully loaded {log}") logger = JSONLogger(path=f"{args.outputPath}/optimizationLogs{len(logs) + 1}.json") optimizer.subscribe(Events.OPTIMIZATION_STEP, logger) # Run optimization print(f"Starting optimisation for {args.algorithm}...") optimizer.maximize(init_points=init_points, n_iter=args.iters) print("Finished optimisation") print(optimizer.max)
def start_jvm( finder: Optional[Callable[..., QuPathJVMInfo]] = None, finder_kwargs: Optional[Dict[str, Any]] = None, ) -> Optional[QuPathVersion]: """start the jvm via jpype This is automatically called at import of `paquo.java`. """ global _QUPATH_VERSION if jpype.isJVMStarted(): return _QUPATH_VERSION # nothing to be done if finder is None: finder = find_qupath if finder_kwargs is None: finder_kwargs = {} # pragma: no cover # For the time being, we assume qupath is our JVM of choice app_dir, runtime_dir, jvm_path, jvm_options = finder(**finder_kwargs) patched_env: Callable[[], ContextManager[Any]] if platform.system() == "Windows": # workaround for EXCEPTION_ACCESS_VIOLATION crash # see: https://github.com/bayer-science-for-a-better-life/paquo/issues/67 @contextmanager def patched_env(): _old = os.environ.copy() os.environ.update({ "PATH": f"{os.path.join(runtime_dir, 'bin')}{os.pathsep}{os.environ['PATH']}" }) try: yield finally: os.environ.clear() os.environ.update(_old) # the above workaround doesn't fix the issue for python versions installed # via the Microsoft Store. Let's warn users that this might cause problems def is_windows_store_python() -> bool: parts = Path(sys.base_exec_prefix).parts try: idx = parts.index("WindowsApps") except ValueError: return False try: return parts[idx + 1].startswith("PythonSoftwareFoundation") except IndexError: return False if finder_kwargs.pop("warn_microsoft_store_python", True) and is_windows_store_python(): msg = dedent("""\ MicrosoftStore Python installation detected Your Python version seems to be installed via the MicrosoftStore. If paquo crashes with a EXCEPTION_ACCESS_VIOLATION try installing Python from https://www.python.org To silence this warning set the following in your .paquo.toml configfile: >>> warn_microsoft_store_python = false <<< """) warn(msg, stacklevel=2) else: patched_env = nullcontext # This is not really needed, but beware we might need SL4J classes (see warning) jpype.addClassPath(str(app_dir / '*')) with patched_env(): try: jpype.startJVM(str(jvm_path), *jvm_options, ignoreUnrecognized=False, convertStrings=False) except RuntimeError as jvm_error: # pragma: no cover # there's a chance that this RuntimeError occurred because a user provided # jvm_option is incorrect. let's try if that is the case and crash with a # more verbose error message try: jpype.startJVM(str(jvm_path), *jvm_options, ignoreUnrecognized=True, convertStrings=False) except RuntimeError: raise jvm_error else: msg = f"Provided JAVA_OPTS prevent the JVM from starting! {jvm_options}" exc = RuntimeError(msg) exc.__cause__ = jvm_error raise exc # we'll do this explicitly here to verify the QuPath version try: _version = str(JClass("qupath.lib.common.GeneralTools").getVersion()) except (TypeError, AttributeError): # pragma: no cover version = _QUPATH_VERSION = None else: version = _QUPATH_VERSION = QuPathVersion(_version) return version
def __init__(self, num_envs=2, max_steps=2000, render_theme=2, frame_skip=0, ai2s=[microrts_ai.passiveAI, microrts_ai.passiveAI], map_path="maps/10x10/basesTwoWorkers10x10.xml", reward_weight=np.array([0.0, 1.0, 0.0, 0.0, 0.0, 5.0])): assert num_envs == len(ai2s), "for each environment, a microrts ai should be provided" self.num_envs = num_envs self.max_steps = max_steps self.render_theme = render_theme self.frame_skip = frame_skip self.ai2s = ai2s self.map_path = map_path self.reward_weight = reward_weight # read map self.microrts_path = os.path.join(gym_microrts.__path__[0], 'microrts') root = ET.parse(os.path.join(self.microrts_path, self.map_path)).getroot() self.height, self.width = int(root.get("height")), int(root.get("width")) # launch the JVM if not jpype._jpype.isStarted(): registerDomain("ts", alias="tests") registerDomain("ai") jars = [ "microrts.jar", "Coac.jar", "Droplet.jar", "GRojoA3N.jar", "Izanagi.jar", "MixedBot.jar", "RojoBot.jar", "TiamatBot.jar", "UMSBot.jar" # "MindSeal.jar" ] for jar in jars: jpype.addClassPath(os.path.join(self.microrts_path, jar)) jpype.startJVM(convertStrings=False) # start microrts client from rts.units import UnitTypeTable self.real_utt = UnitTypeTable() from ai.rewardfunction import RewardFunctionInterface, WinLossRewardFunction, ResourceGatherRewardFunction, AttackRewardFunction, ProduceWorkerRewardFunction, ProduceBuildingRewardFunction, ProduceCombatUnitRewardFunction, CloserToEnemyBaseRewardFunction self.rfs = JArray(RewardFunctionInterface)([ WinLossRewardFunction(), ResourceGatherRewardFunction(), ProduceWorkerRewardFunction(), ProduceBuildingRewardFunction(), AttackRewardFunction(), ProduceCombatUnitRewardFunction(), # CloserToEnemyBaseRewardFunction(), ]) self.start_client() # computed properties # [num_planes_hp(5), num_planes_resources(5), num_planes_player(5), # num_planes_unit_type(z), num_planes_unit_action(6)] self.num_planes = [5, 5, 3, len(self.utt['unitTypes'])+1, 6] self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(self.height, self.width, sum(self.num_planes)), dtype=np.int32) self.action_space = gym.spaces.MultiDiscrete([ self.height * self.width, 6, 4, 4, 4, 4, len(self.utt['unitTypes']), 7 * 7 ])