def load(self, warn=True):
# capture all error messages
oldErr = _system.err
_system.setErr(_pstream(_NoOutputStream()))
try:
jdh = self._loadFile()
finally:
_system.setErr(oldErr)
data = asDatasetList(jdh.getList())
names = jdh.getNames()
basenames = []
from os import path as _path
for n in names: # remove bits of path so sanitising works
if _path.exists(n):
basenames.append(_path.basename(n))
else:
basenames.append(n)
if len(data) != len(basenames):
raise io_exception, "Number of names does not match number of datasets"
metadata = None
if self.load_metadata:
meta = jdh.getMetadata()
if meta:
mnames = meta.metaNames
if mnames:
metadata = [(k, meta.getMetaValue(k)) for k in mnames]
return DataHolder(zip(basenames, data), metadata, warn)
def test_faulty_callback(self):
import java.lang.System as Sys
import java.io.PrintStream as PrintStream
import java.io.OutputStream as OutputStream
class NullOutputStream(OutputStream):
def write(self, b):
pass
def write(self, buf, offset, len):
pass
syserr = Sys.err
Sys.setErr(PrintStream(NullOutputStream()))
tools.register(self.faulty_callback)
tools.register(self.assert_callback)
tools.register(self.faulty_callback2)
self.count = 0
try:
eval("42+1")
finally:
self.assertTrue(tools.unregister(self.faulty_callback))
self.assertTrue(tools.unregister(self.faulty_callback2))
self.assertTrue(tools.unregister(self.assert_callback))
Sys.setErr(syserr)
self.assertEqual(self.count, 1)
def load(self, warn=True):
# capture all error messages
oldErr = _system.err
_system.setErr(_pstream(_NoOutputStream()))
try:
jdh = self._loadFile()
finally:
_system.setErr(oldErr)
data = asDatasetList(jdh.getList())
names = jdh.getNames()
basenames = []
from os import path as _path
for n in names: # remove bits of path so sanitising works
if _path.exists(n):
basenames.append(_path.basename(n))
else:
basenames.append(n)
if len(data) != len(basenames):
raise io_exception("Number of names does not match number of datasets")
metadata = None
if self.load_metadata:
meta = jdh.getMetadata()
if meta:
mnames = meta.metaNames
if mnames:
metadata = [ (k, meta.getMetaValue(k)) for k in mnames ]
return DataHolder(list(zip(basenames, data)), metadata, warn)
def CommandEntered(self, event):
if event.source.text == 'exit':
# let's kill the frame
System.setOut(self.__outOriginal)
System.setErr(self.__errOriginal)
self.dispose()
else:
# echo the input to the text area using the printstream
s = 'in : ' + event.source.text
self.printStream.println(s)
# try the embedded interp (the getLocals was just to see if I could interact with it)
# it's not returning anything
a = self.interpreter.getLocals()
self.printWriter.println(a)
self.interpreter.exec(event.source.txt)
# try the main interp (the getLocals was just to see if I could interact with it)
# it's not returning anything
a = getLocals()
self.printWriter.println(a)
exec(event.source.txt)
# set the input text blank and give it focus back. we don't get here if we try to use
# the interpreter, though we do when we don't try to interact with the interpreter
self.inputField.setText('')
self.inputField.requestFocus()
def compile(wd,args):
print "changing working directory to %s" % wd
System.setProperty("user.dir",wd);
print args
outstream = ByteArrayOutputStream()
errstream = ByteArrayOutputStream()
System.setOut(PrintStream(outstream))
System.setErr(PrintStream(errstream))
try: Tom.exec(config + args)
except: pass
return str((outstream.toString(),errstream.toString()))
def __init__(self, *args, **kwargs):
super(VTLKernel, self).__init__(*args, **kwargs)
startJVM()
from java.lang import System
from java.io import ByteArrayOutputStream
from java.io import PrintStream
self.baos = ByteArrayOutputStream()
ps = PrintStream(self.baos)
System.setOut(ps)
System.setErr(ps)
it = JPackage('it')
self.VTLSession = it.bancaditalia.oss.vtl.config.ConfigurationManager.getDefault().createSession()
def __init__(self):
JFrame.__init__(self, 'MagicDraw Jython Console')
# grab the current out and err so we can set them back later (for the main java
# System.out/err, not the PythonInterpreter
self.__outOriginal = System.out
self.__errOriginal = System.err
# use the printStream as it updates the textarea
System.setOut(self.printStream)
System.setErr(self.printStream)
self.CreateComponents()
self.setVisible(True)
self.requestFocus()
self.inputField.requestFocus()
def _load_tree(self):
# capture all error messages
from java.lang import System #@UnresolvedImport
from java.io import PrintStream #@UnresolvedImport
oldErr = System.err
System.setErr(PrintStream(_NoOutputStream())) #@UndefinedVariable
tree = None
try:
tree = self.ldr.loadTree()
finally:
System.setErr(oldErr) #@UndefinedVariable
return tree
def astral_tree(args):
astral, input_file, output_file = args
print('ASTRAL processing %s has begun' % input_file)
jpype.startJVM(jpype.getDefaultJVMPath(),
'-Djava.class.path=%s' % astral,
convertStrings=False)
from java.lang import System
from java.io import PrintStream, File
System.setOut(PrintStream(File('/dev/null')))
System.setErr(PrintStream(File('/dev/null')))
jpype.imports.registerDomain('phylonet')
from phylonet.coalescent import CommandLine
CommandLine.main(['-i', input_file, '-o', output_file])
jpype.shutdownJVM()
def wrapper(*args):
sysout = sys.stdout
syserr = sys.stderr
javaOut = System.out
javaErr = System.err
sys.stdout = DevNull()
sys.stderr = DevNull()
System.setOut(DevNull())
System.setErr(DevNull())
result = func(*args)
sys.stdout = sysout
sys.stderr = syserr
System.setOut(javaOut)
System.setErr(javaErr)
return result
def _runCommand(cmd, runDir=None):
if runDir is not None:
currWorkingDir = os.getcwd()
os.chdir(runDir)
cmd = shlex.split(cmd)
bosErr = ByteArrayOutputStream()
origStdErr = System.err
System.setErr(PrintStream(bosErr))
process = subprocess.Popen(cmd, stdout=subprocess.PIPE)
System.setErr(origStdErr)
if runDir is not None:
os.chdir(currWorkingDir)
if process.wait() != 0:
errorStr = "Failed to call '%s'. Error: %s" % (
cmd, String(bosErr.toByteArray()))
_fail(errorStr)
return process.communicate()[0]
def load(self, warn=True):
# capture all error messages
from java.lang import System #@UnresolvedImport
from java.io import PrintStream #@UnresolvedImport
oldErr = System.err
System.setErr(PrintStream(_NoOutputStream())) #@UndefinedVariable
tree = None
try:
tree = self.ldr.loadTree()
finally:
System.setErr(oldErr) #@UndefinedVariable
if tree is None:
raise io_exception, "No tree found"
# convert tree to own tree
r = tree.getNodeLink()
pool = dict()
return self._copynode(pool, r)
def load(self, warn=True):
# capture all error messages
from java.lang import System #@UnresolvedImport
from java.io import PrintStream #@UnresolvedImport
oldErr = System.err
System.setErr(PrintStream(_NoOutputStream())) #@UndefinedVariable
tree = None
try:
tree = self.ldr.loadTree()
finally:
System.setErr(oldErr) #@UndefinedVariable
if tree is None:
raise io_exception, "No tree found"
# convert tree to own tree
r = tree.getNodeLink()
pool = dict()
return self._copynode(pool, r)
def main():
sw = StackWindow("Show Exception Stack", 600, 400)
handler = sw
Thread.setDefaultUncaughtExceptionHandler(handler)
System.setOut(sw.printStream)
System.setErr(sw.printStream)
swing.UIManager.setLookAndFeel(
swing.UIManager.getSystemLookAndFeelClassName())
frm = FrmMain(current_folder)
frm.visible = True
editor_app = frm
plotjy.jyplot.figure_parent = editor_app.getFigureDock()
#print plotjy.jyplot.figure_parent
interp = frm.getConsoleDockable().getInterpreter()
interp.getSystemState().path = sys.path
interp.exec('import plotjy')
def _set_interactive(self, interactive):
# deactivate all handlers
if not interactive:
debug("disable default JVM output streams")
if self.silent_streams is None:
self.silent_streams = streams(SyslogOutputStream(), SyslogOutputStream(SyslogOutputStream.ERR))
System.out.flush()
System.err.flush()
System.setOut(PrintStream(self.silent_streams.out, True))
System.setErr(PrintStream(self.silent_streams.err, True))
else:
debug("enable default JVM output streams")
System.out.flush()
System.err.flush()
System.setOut(self.original_streams.out)
System.setErr(self.original_streams.err)
# FIXME boadcast configuration change to connection managers
if self.connection is not None and self.connection.jcli is not None:
self.connection.jcli.set_silent(not interactive)
def __init__(self, max_iterations=2, grammar='grammar.yaml'):
super().__init__()
# noinspection PyUnresolvedReferences
# startJVM is the right function
jpype.startJVM(classpath=[
str(
Path(__file__).parent /
"test_starlib_mcts-1.0-SNAPSHOT-all.jar")
])
jpype.imports.registerDomain("isml.aidev")
# noinspection PyUnresolvedReferences
from java.lang import System
# noinspection PyUnresolvedReferences
from java.io import PrintStream, File
# noinspection PyUnresolvedReferences
System.setErr(PrintStream(File("ailibs.log"))) #
# noinspection PyUnresolvedReferences
from isml.aidev import Algorithm
self.algo = Algorithm(max_iterations, grammar)
self._initialized = True
def test_faulty_callback(self):
import java.lang.System as Sys
import java.io.PrintStream as PrintStream
import java.io.OutputStream as OutputStream
class NullOutputStream(OutputStream):
def write(self, b): pass
def write(self, buf, offset, len): pass
syserr = Sys.err
Sys.setErr(PrintStream(NullOutputStream()))
tools.register(self.faulty_callback)
tools.register(self.assert_callback)
tools.register(self.faulty_callback2)
self.count=0
try:
eval("42+1")
finally:
self.assertTrue(tools.unregister(self.faulty_callback))
self.assertTrue(tools.unregister(self.faulty_callback2))
self.assertTrue(tools.unregister(self.assert_callback))
Sys.setErr(syserr)
self.assertEqual(self.count, 1)
def connectMonkey():
id = getId()
device = getDevice()
from java.io import File, PrintStream, ByteArrayOutputStream
from java.lang import System
outFile = ByteArrayOutputStream(100)
errFile = ByteArrayOutputStream(100)
System.setOut(PrintStream(outFile))
System.setErr(PrintStream(errFile))
# Helps start adb if not started
# pid of monkeyrunner only exists starting sdk 2.3
pid = getpid()
if id is None:
device = MonkeyRunner.waitForConnection()
else:
device = MonkeyRunner.waitForConnection(20, id)
if pid is None:
if outFile.size() > 0:
# call connect again
if id is None:
device = MonkeyRunner.waitForConnection()
else:
device = MonkeyRunner.waitForConnection(20, id)
print device
# Need 2nd connection calls to get the device
# see defect http://code.google.com/p/android/issues/detail?id=16722
#if id is None:
# device = MonkeyRunner.waitForConnection()
#else:
# device = MonkeyRunner.waitForConnection(20, id)
setDevice(device)
return device
def __del__(self):
System.setOut(self.__outOriginal)
System.setErr(self.__errOriginal)
print 'Goodbye'
__file__ = inspect.getframeinfo(inspect.currentframe())[0]
config = ConfigParser.ConfigParser()
config.read( "{0}/asbmansnmp.cfg".format(os.path.dirname(os.path.abspath(__file__))))
# set up logging
logging.basicConfig( filename = config.get("settings","logfile"), level=logging.INFO,format='%(asctime)s:' + logging.BASIC_FORMAT)
servers = config.sections()
timeout = config.getint("settings","timeout")
debug = config.getboolean("settings","debug")
#discard all java output, it would mess up pass_persist communication
if not debug:
nulloutput = PrintStream(NullOutputStream())
javasystem.setErr(nulloutput)
javasystem.setOut(nulloutput)
# list of information we want to write to files / snmp
properties = [ ['ActiveServers', 1],
['RqDuration', ["Max","Avg"]],
['RqWait', ["Max","Avg"]],
['ActiveClients', ['Now','Peak']],
['TotalRequests', 1],
['BusyServers', 1],
['AvailableServers', 1],
['ClientQueueDepth', ['Cur','Max']],
['LockedServers', 1],
['Status', 1],
['MaxAgents', 1],
['MaxClients', 1]
config.read("{0}/asbmansnmp.cfg".format(
os.path.dirname(os.path.abspath(__file__))))
# set up logging
logging.basicConfig(filename=config.get("settings", "logfile"),
level=logging.INFO,
format='%(asctime)s:' + logging.BASIC_FORMAT)
servers = config.sections()
timeout = config.getint("settings", "timeout")
debug = config.getboolean("settings", "debug")
#discard all java output, it would mess up pass_persist communication
if not debug:
nulloutput = PrintStream(NullOutputStream())
javasystem.setErr(nulloutput)
javasystem.setOut(nulloutput)
# list of information we want to write to files / snmp
properties = [['ActiveServers', 1], ['RqDuration', ["Max", "Avg"]],
['RqWait', ["Max", "Avg"]], ['ActiveClients', ['Now', 'Peak']],
['TotalRequests', 1], ['BusyServers', 1],
['AvailableServers', 1], ['ClientQueueDepth', ['Cur', 'Max']],
['LockedServers', 1], ['Status', 1], ['MaxAgents', 1],
['MaxClients', 1]]
statusses = {"ACTIVE": 3, "STARTING": 2, "STOPPING": 1, "STOPPED": 0}
class Unbuffered:
def __init__(self, stream):
self.stream = stream
