def getTrackRois(resultstable):
rt = resultstable
nextframeA = rt.getColumn(rt.getColumnIndex('NextFrame'))
sliceA = rt.getColumn(rt.getColumnIndex('Slice'))
xA = rt.getColumn(rt.getColumnIndex('X'))
yA = rt.getColumn(rt.getColumnIndex('Y'))
imp = IJ.getImage()
donecheckA = list(range(len(nextframeA)))
roisA = []
for i, slicenum in enumerate(sliceA):
if slicenum == 1:
roix = [int(xA[i])]
roiy = [int(yA[i])]
ci = i
print 'Start', roix, roiy
count = 0
while (nextframeA[int(ci)] != -1) and (slicenum < 160) and count<160:
nexti = int(nextframeA[ci])
nextslice = int(sliceA[nexti])
roix.append(int(xA[nexti]))
roiy.append(int(yA[nexti]))
#print '...', int(xA[nexti]), int(yA[nexti])
ci = nexti
slicenum = nextslice
count +=1
#print roix
if len(roix) > 1:
jroix = jarray.array(roix, 'f')
jroiy = jarray.array(roiy, 'f')
pr = PolygonRoi(jroix, jroiy , len(roix), Roi.POLYLINE)
roisA.append(pr)
def intensityPlotter(path, pathid, meanMax, maxMax, meanMin, maxMin, pathlenMax): #path = pathdict[pathid] if len(path.nucs) < 5: print 'Path', pathid, ' omitted since only', str(len(path.nucs)), 'p[oints sampled' return mean = [] sd = [] max = [] frames = [] for nuc in path.nucs: mean.append(float(nuc.mean)) sd.append(float(nuc.sd)) max.append(float(nuc.max)) frames.append(float(nuc.frame)) jmean = jarray.array(mean , 'd') jframes =jarray.array(frames , 'd') jmax = jarray.array(max , 'd') plottitle = "Plot nucleus " + str(int(pathid)) # pt = Plot(plottitle, "Frames", "Intensity") pt = Plot(plottitle, "Frames", "Intensity") pt.setLimits(0, pathlenMax+1, meanMin, maxMax) pt.setColor(Color.red) pt.addPoints(jframes, jmean, pt.LINE) pt.setColor(Color.lightGray ) pt.addPoints(jframes, jmax, pt.LINE) #pt.addPoints(jframes, jmean, pt.CIRCLE) #pt.draw() pt.show()
def on_falsePositiveBtn_clicked(self, event):
"""Tell the tool server that selected error is a false positive
"""
check = self.selectedError.check
tool = check.tool
if tool.falseFeedbackMode == "url":
#the tool supports automatic reporting
if self.properties.getProperty("false_positive_warning.%s" % tool.name) == "on":
messageArguments = array([tool.title], String)
formatter = MessageFormat("")
formatter.applyPattern(self.strings.getString("false_positive_confirmation"))
msg = formatter.format(messageArguments)
options = [self.strings.getString("yes_do_not_ask_the_next_time"),
self.strings.getString("Yes"),
self.strings.getString("No")]
answer = JOptionPane.showOptionDialog(Main.parent,
msg,
self.strings.getString("flagging_a_false_positive"),
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.WARNING_MESSAGE,
None,
options,
options[2])
if answer == 0:
#don't ask again
self.properties.setProperty("false_positive_warning.%s" % tool.name,
"off")
self.save_config(self)
elif answer == 2:
#don't flag as false positive
return
tool.sayFalseBug(self.selectedError, check)
elif tool.falseFeedbackMode == "msg":
#the tool supports manual reporting of false positives
if self.properties.getProperty("false_positive_warning.%s" % tool.name) == "on":
messageArguments = array([tool.title], String)
formatter = MessageFormat("")
formatter.applyPattern(self.strings.getString("manual_false_positive_confirmation"))
msg = formatter.format(messageArguments)
options = [self.strings.getString("yes_do_not_ask_the_next_time"),
self.strings.getString("Yes"),
self.strings.getString("No")]
answer = JOptionPane.showOptionDialog(Main.parent,
msg,
self.strings.getString("flagging_a_false_positive"),
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.WARNING_MESSAGE,
None,
options,
options[2])
errorInfo = [tool.title,
check.name,
self.selectedError.errorId,
self.selectedError.osmId]
self.falsePositiveDlg.tableModel.addRow(errorInfo)
else:
#the tool does not support feedback
return
self.editDone()
def main():
# see: http://www.eclipse.org/jetty/documentation/current/embedding-jetty.html
server = Server(8080)
rootHandler = ContextHandlerCollection()
childHandlers = ArrayList()
## Web Sockets
websocketContext = ContextHandler(rootHandler, "/wstest")
websocketContext.setAllowNullPathInfo(True) # so "/wstest" is not redirected to "/wstest/"
websocketHandler = TestWebSocketHandler()
websocketContext.setHandler(websocketHandler)
childHandlers.add(websocketContext)
## Files
resourceContext = ContextHandler(rootHandler, "/")
resourceHandler = ResourceHandler()
resourceHandler.setDirectoriesListed(True)
resourceHandler.setWelcomeFiles(array(["index.html"], String))
resourceDirectory = pycycle_dealer.getResourceDirectoryForModuleName(__name__)
resourceHandler.setResourceBase(resourceDirectory)
resourceContext.setHandler(resourceHandler)
childHandlers.add(resourceContext)
## DefaultHandler
childHandlers.add(DefaultHandler())
rootHandler.setHandlers(array(childHandlers, Handler))
server.setHandler(rootHandler)
server.start()
server.join()
def testCopyItems(self):
if isjava:
import jarray
print "test copy items"
da = np.array(self.db, np.float)
ta = np.zeros(da.getShape())
da.copyItemsFromAxes(None, None, ta)
print ta.getBuffer()
ta = np.array(self.m)
da.setItemsOnAxes(None, None, ta.getBuffer())
print da.getBuffer()
print '2'
da = np.array(self.db, np.float)
ta = np.zeros((2,))
axes = [ True, False ]
da.copyItemsFromAxes(None, axes, ta)
print ta.getBuffer()
ta = jarray.array([ -2, -3.4 ], 'd')
da.setItemsOnAxes(None, axes, ta)
print da.getBuffer()
print '3'
da = np.array(self.db, np.float)
ta = np.zeros((2,))
axes = [ False, True ]
da.copyItemsFromAxes(None, axes, ta)
print ta.getBuffer()
ta = jarray.array([ -2.5, -3.4 ], 'd')
da.setItemsOnAxes(None, axes, ta)
print da.getBuffer()
def test_jarray(self):
from java.lang import String
self.assertEqual(sum(jarray.array(range(5), "i")), 10)
self.assertEqual(",".join(jarray.array([String("a"), String("b"), String("c")], String)), u"a,b,c")
self.assertEqual(sum(jarray.zeros(5, "i")), 0)
self.assertEqual([x for x in jarray.zeros(5, String)], [None, None, None, None, None])
def _attack(self, basePair, payloads, taint, request_template, referer):
proto = helpers.analyzeRequest(basePair).getUrl().getProtocol() + '://'
if 'abshost' in payloads:
payloads['abshost'] = proto + payloads['abshost']
payloads['referer'] = proto + taint + '/' + referer
# Load the supplied payloads into the request
if 'xfh' in payloads:
payloads['xfh'] = "\r\nX-Forwarded-Host: " + payloads['xfh']
for key in ('xfh', 'abshost', 'host', 'referer'):
if key not in payloads:
payloads[key] = ''
# Ensure that the response to our request isn't cached - that could be harmful
payloads['cachebust'] = str(time.time())
request = request_template.substitute(payloads)
attack = callbacks.makeHttpRequest(basePair.getHttpService(), request)
response = safe_bytes_to_string(attack.getResponse())
requestHighlights = [jarray.array([m.start(), m.end()], 'i') for m in
re.finditer('(' + '|'.join(payloads.values()) + ')',
safe_bytes_to_string(attack.getRequest()))]
responseHighlights = [jarray.array([m.start(), m.end()], 'i') for m in re.finditer(taint, response)]
attack = callbacks.applyMarkers(attack, requestHighlights, responseHighlights)
return attack, response
def array(x1,x2,x3=None,x4=None):
if x3 and x4:
return jarray.array([x1,x2,x3,x4],Class.forName('[[F'))
elif x3:
return jarray.array([x1,x2,x3],Class.forName('[[F'))
else:
return jarray.array([x1,x2],Class.forName('[[F'))
def histogram(self, low=None, high=None, nbins=None):
"""
Computes a histogram for the raster.
*low* specifies the lowest (inclusive) pixel value to include and *high*
specifies the highest (exclusive) pixel value to include.
*nbins* specifies the number of bins/buckets of the resulting histogram.
This method returns a :class:`Histogram <geoscript.layer.raster.Histogram>`
instance.
"""
nb = len(self.bands)
params = {'Source': self._coverage}
if low:
low = low if isinstance(low, (tuple, list)) else [low]*nb
params['lowValue'] = array(low, 'd')
if high:
high = high if isinstance(high, (tuple, list)) else [high]*nb
params['highValue'] = array(high, 'd')
if nbins:
nbins = nbins if isinstance(nbins, (tuple, list)) else [nbins]*nb
params['numBins'] = array(nbins, 'i')
h = self._op('Histogram', **params).getProperty('histogram')
return Histogram(h)
def testCopyItems(self):
if isjava:
import jarray
print "test copy items"
da = np.array(self.db, np.float)
jda = da._jdataset()
ta = np.zeros(da.shape)
jda.copyItemsFromAxes(None, None, ta._jdataset())
print ta.data
ta = np.array(self.m)
jda.setItemsOnAxes(None, None, ta.data)
print da.data
print '2'
da = np.array(self.db, np.float)
jda = da._jdataset()
ta = np.zeros((2,))
axes = [ True, False ]
jda.copyItemsFromAxes(None, axes, ta._jdataset())
print ta.data
ta = jarray.array([ -2, -3.4 ], 'd')
jda.setItemsOnAxes(None, axes, ta)
print da.data
print '3'
da = np.array(self.db, np.float)
jda = da._jdataset()
ta = np.zeros((2,))
axes = [ False, True ]
jda.copyItemsFromAxes(None, axes, ta._jdataset())
print ta.data
ta = jarray.array([ -2.5, -3.4 ], 'd')
jda.setItemsOnAxes(None, axes, ta)
print da.data
def test_jarray(self): # until it is fully formally removed
# While jarray is still being phased out, just flex the initializers.
# The rest of the test for array will catch all the big problems.
import jarray
jarray.array(range(5), 'i')
jarray.array([String("a"), String("b"), String("c")], String)
jarray.zeros(5, 'i')
jarray.zeros(5, String)
def test_boxing_conversion(self):
"array objects support boxing, as they did in Jython 2.1"
from java.lang import Integer
self.assertAsList(jarray.array([1, 2, 3, 4, 5], Integer), [1, 2, 3, 4, 5])
self.assertAsList(array(Integer, [1, 2, 3, 4, 5]), [1, 2, 3, 4, 5])
self.assertAsList(jarray.array([1, 2, 3, 4, 5], "i"), [1, 2, 3, 4, 5])
self.assertAsList(array("i", [1, 2, 3, 4, 5]), [1, 2, 3, 4, 5])
def startWebLogic(domainDir, timeOut=300):
if isWindows():
pb = ProcessBuilder(jarray.array(["cmd", "/c", "startWebLogic.cmd"], String))
else:
pb = ProcessBuilder(jarray.array(["sh", "startWebLogic.sh"], String))
pb.directory(File(domainDir))
pb.redirectErrorStream(Boolean.TRUE);
p = pb.start()
waitFor(p, timeOut)
def __div__(self, other):
if isinstance(other, Raster):
result = self._op('DivideIntoConst', Source=other._coverage, constants=
array([1], 'd'))
return self.__mul__(Raster(other._format, coverage=result))
else:
result = self._op('DivideByConst', Source=self._coverage, constants=
array(other if isinstance(other, (list,tuple)) else [other], 'd'))
return Raster(self._format, coverage=result)
def addURL(self, u):
"""Purpose: Call this with u= URL for
the new Class/jar to be loaded
"""
method = self.url_class_loader.getDeclaredMethod("addURL", [URL])
method.setAccessible(1)
jarray.array([u], java.lang.Object)
method.invoke(self.system_class_loader, [u])
return u
def _helper(self, array):
'''Runs all of the algorithms with the given array'''
sortedArray = array[:]
sortedArray.sort()
jArray = jarray.array(sortedArray, java.lang.Integer)
for method in METHODS:
arrayCopy = jarray.array(array, java.lang.Integer)
method(arrayCopy)
self.assertEqual(jArray, arrayCopy, "Failed method %s during %s" %
(method.__name__, inspect.stack()[1][3]))
def createEvent(size):
event = StructuredEvent()
eventType = EventType("testDomain", "testType");
fixedHeader = FixedEventHeader(eventType, "testing");
variableHeader = array([], Property);
event.header = EventHeader(fixedHeader, variableHeader);
event.filterable_data = array([], Property)
event.remainder_of_body = orb.create_any()
event.remainder_of_body.insert_longlong(System.currentTimeMillis())
return event
def addFile_try (u):
parameters = jarray.array([java.net.URL], java.lang.Class)
sysloader = java.lang.ClassLoader.getSystemClassLoader()
sysclass = java.net.URLClassLoader
method = sysclass.getDeclaredMethod("addURL", parameters)
a = method.setAccessible(1)
jar_a = jarray.array([u], java.lang.Object)
#b = method.invoke(sysloader, jar_a)
method.invoke(java.lang.ClassLoader.getSystemClassLoader(), jar_a)
return u
def pn_connection_open(conn):
props = dat2obj(conn.properties)
offered = dat2obj(conn.offered_capabilities)
desired = dat2obj(conn.desired_capabilities)
if props:
conn.impl.setProperties(props)
if offered:
conn.impl.setOfferedCapabilities(array(list(offered), Symbol))
if desired:
conn.impl.setDesiredCapabilities(array(list(desired), Symbol))
conn.impl.open()
def addToCustomer(mc,island,custId,corpus='/tmp/corpus'):
print 'addToCustomer()'
amptool = ActiveMailboxPartitionTool()
emscmdtool = EmsCommandLineTool()
print 'executing amp cluster-location'
amptool.runCommand('cluster-location',array(['-r'],String))
args = []
args.append("-f" )
args.append( str(island))
args.append("-s" )
args.append( str(island))
args.append( "-i" )
args.append( corpus)
args.append( "-o" )
args.append( "/tmp")
args.append( "-r" )
args.append( "equal-to-sent")
args.append( "-c")
args.append(str(custId))
args.append( "-q")
argsArr = array(args,String)
print 'executing make-test-customer'
result = emscmdtool.runCommand('make-test-customer',argsArr)
if result is False:
raise Exception('make-test-customer failed, customer already exists?')
ManagementContainer.getInstance().getMailRoutingConfigGenerator().waitForRegenComplete()
# ensure policy_exploded_users updates with user account info
rpm = mc.getRetentionPolicyManager()
rpm.notifyOfExternalPolicyChanges(int(custId))
# move the contents of staging to sftp.drop
src = os.path.join('/tmp',str(custId))
dst = os.path.join('/ems/bigdisk/sftp.drop',str(custId))
if not os.path.exists(dst):
os.mkdir(dst)
for f in os.listdir(src):
if f.endswith('.gzip.enc.done.ftp'):
shutil.copy(os.path.join(src,f),dst)
os.remove(os.path.join(src,f))
idxF = f.replace('.gzip.enc.done.ftp','.index.done.ftp')
shutil.copy(os.path.join(src,idxF),dst)
os.remove(os.path.join(src,idxF))
shutil.rmtree(src)
return
def _attack(self, basePair, insertionPoint, payloads, taint):
proto = self._helpers.analyzeRequest(basePair).getUrl().getProtocol()+'://'
if('abshost' in payloads):
payloads['abshost'] = proto + payloads['abshost']
payloads['referer'] = proto + taint + '/' + self._referer
print "Host attack: "+str(payloads)
attack = callbacks.makeHttpRequest(basePair.getHttpService(), insertionPoint.buildRequest('hosthacker'+pickle.dumps(payloads)))
response = self._helpers.bytesToString(attack.getResponse())
requestHighlights = [jarray.array([m.start(),m.end()], 'i') for m in re.finditer('('+'|'.join(payloads.values())+')', self._helpers.bytesToString(attack.getRequest()))]
responseHighlights = [jarray.array([m.start(),m.end()], 'i') for m in re.finditer(taint, response)]
attack = callbacks.applyMarkers(attack, requestHighlights, responseHighlights)
return (attack, response)
def natblascheck():
from no.uib.cipr.matrix.nni import BLAS
from jarray import array
x = array([1.1,2.2,3.3,4.4],'d')
y = array([1.1,2.2,3.3,4.4],'d')
n = len(x)
dot = BLAS.dot(n,x,1,y,1)
print dot
def natlapackcheck():
from no.uib.cipr.matrix.nni import LAPACK;
from jarray import array
iseed = array([1998,1999,2000,2001],'i')
x = array([0,0,0,0,0,0,0,0,0,0],'d')
n = array([len(x)],'i')
LAPACK.laruv(iseed, n, x);
print "Answer:"
for i in x:
print i
def test(keys=undefined, index=undefined, **options):
"""Run the tests."""
reloadSystem()
tests = collectTests(keys, index, saveArguments=true)
from Compiler import Compiler
runConstraintTests()
for test in tests:
c = Compiler(**options)
try:
from jarray import array
bytes = c.compile(test)
array(bytes, 'b')
except:
print "During compilation of %r" % test
raise
def node_to_coordinates(aff,nd):
fp = array([nd.x, nd.y], 'f')
aff.transform(fp, 0, fp, 0, 1)
x = fp[0] * pw
y = fp[1] * ph
z = float(nd.layer.z) * pw
return (x,y,z)
def auto_typed_set(key, value):
key_type = type_for(key)
#
# Don't do anything if the value is not specified
#
if value == None:
return
if key_type == 'int': # or key_type == 'long':
if value.strip(): # Value is a non empty string
print 'Setting integer property ' + key + ' to ' + value
set(key,int(value))
elif key_type == 'boolean':
if value.strip(): # Value is a non empty string
print 'Setting boolean property ' + key + ' to ' + value
if value == 'True' or value == 'true' or value == '1':
real_value = 'true'
else:
real_value = 'false'
set(key,real_value)
elif key_type == 'float':
if value.strip(): # Value is a non empty string
print 'Setting float property ' + key + ' to ' + value
set(key,float(value))
elif key_type == 'array':
if value.strip(): # Value is a non empty string
print 'Setting array property ' + key + ' to ' + value
set(key, jarray.array(value, String))
else:
print 'Setting generic property ' + key + ' to ' + value
set(key,value)
def __init__(self):
dataDir = Settings.dataDir + 'WorkingWith2DBarcodes/Utility2DBarcodeFeatures/GenerateMultipleMacroPdf417Barcodes/'
# Instantiate barcode object
builder = BarCodeBuilder()
symbology= Symbology
builder.setSymbologyType(symbology.MacroPdf417)
# Create array for storing multiple barcodes
i = 1
size = 4
list_code_text = array("code-1", "code-2", "code-3", "code-last")
str_file_id = 1
# Check the listbox for getting codetext and generating the barcodes
while (i<=size):
builder.setCodeText(list_code_text[i - 1])
# fileID should be same for all the generated barcodes
builder.setMacroPdf417FileID(str_file_id)
# Assign segmentID in increasing order (1,2,3,....)
builder.setMacroPdf417SegmentID(i)
# Save the barcode (fileid_segmentid.png)
builder.save(dataDir + "#{i}.png")
# Display Status
print "Saved Images Successfully."
def main(n):
list = [random.randint(java.lang.Integer.MIN_VALUE, java.lang.Integer.MAX_VALUE) for x in range(n)]
jArray = jarray.array(list, java.lang.Integer)
print "List size: " + str(n)
for method in METHODS:
runSort(method, jArray)
print ""
def getFilesAndAnalyze(folder):
count = 0
timeseries = []
for root, directories, filenames in os.walk(folder):
print directories
for filename in sorted(filenames):
#print filenames
if not (("_1.tif" in filename) and ("2views_2" in filename)):
continue
else:
#print root
#print directories
#print filename
timeseries = appendFileToArray(timeseries, root, filename)
count = count + 1
if count>10000:
break
calib = timeseries[0].getCalibration()
jaimp = array(timeseries, ImagePlus)
nc = 1
nz = timeseries[0].getImageStack().getSize()
nt = len(timeseries)
print nc,nz,nt
allimp = Concatenator().concatenate(jaimp, False)
allimp.setDimensions(nc, nz, nt)
allimp.setCalibration(calib)
allimp.setOpenAsHyperStack(True)
allimp.show()
def inet_ntop(family, packed_ip):
try:
jByteArray = jarray.array(packed_ip, 'b')
ia = java.net.InetAddress.getByAddress(jByteArray)
return ia.getHostAddress()
except java.lang.Exception, jlx:
raise _map_exception(jlx)
jPropertyStructure = Vector()
for chunk in propertyStructure:
className = chunk.pop(0)
groupVec = Vector()
for group in chunk:
groupName = group.pop(0)
propVec = Vector()
for propertyName in group:
propVec.add(propertyName)
groupVec.add(StringObjectPair(groupName, propVec))
jPropertyStructure.add(StringObjectPair(className, groupVec))
AuthoringToolResources.setPropertyStructure(jPropertyStructure)
AuthoringToolResources.setClassesToOmitNoneFor(
array(classesToOmitNoneFor, java.lang.Class))
pairs = []
for item in propertiesToOmitNoneFor:
pairs.append(StringTypePair(item[0], java.lang.Class.forName(item[1])))
AuthoringToolResources.setPropertiesToOmitNoneFor(array(pairs, StringTypePair))
pairs = []
for item in propertiesToIncludeNoneFor:
pairs.append(StringTypePair(item[0], java.lang.Class.forName(item[1])))
AuthoringToolResources.setPropertiesToIncludeNoneFor(
array(pairs, StringTypePair))
pairs = []
for item in propertyNamesToOmit:
pairs.append(StringTypePair(item[0], java.lang.Class.forName(item[1])))
def _currentKeyValues(self):
return array([None if self.code == None else int(self.code)], Object)
def _str2bytes(s):
return jarray.array(map(_long2byte, map(ord, s)), 'b')
def getPosition(self):
resultList = list(self.readout())
resultJavaArray = jarray.array(resultList, 'd')
return resultJavaArray
from net.grinder.script.Grinder import grinder
from net.grinder.script import Test
from jarray import array
import sys
from java.lang import *
from java.util import Properties
from org.omg.CORBA import *
from org.omg.CosNotifyChannelAdmin import *
from org.omg.CosNotifyComm import *
from org.omg.CosNotification import *
from thread import *
log = grinder.logger.output
# setup ORB
args = array([], String)
props = Properties()
props.put("org.omg.CORBA.ORBClass", "org.jacorb.orb.ORB")
props.put("org.omg.CORBA.ORBSingletonClass", "org.jacorb.orb.ORBSingleton")
orb = ORB.init(args, props)
poa = orb.resolve_initial_references("RootPOA")
poa.the_POAManager().activate()
# start ORB thread
def run_orb():
orb.run()
start_new_thread(run_orb, ())
class TrustAllX509TrustManager(X509TrustManager):
'''Define a custom TrustManager which will blindly accept all
certificates'''
def checkClientTrusted(self, chain, auth):
pass
def checkServerTrusted(self, chain, auth):
pass
def getAcceptedIssuers(self):
return None
# Create a static reference to an SSLContext which will use
# our custom TrustManager
trust_managers = array([TrustAllX509TrustManager()], TrustManager)
TRUST_ALL_CONTEXT = SSLContext.getInstance("SSL")
TRUST_ALL_CONTEXT.init(None, trust_managers, None)
# Keep a static reference to the JVM's default SSLContext for restoring
# at a later time
DEFAULT_CONTEXT = SSLContext.getDefault()
def trust_all_certificates(f):
'''Decorator function that will make it so the context of the decorated
method will run with our TrustManager that accepts all certificates'''
def wrapped(*args, **kwargs):
# Only do this if running under Jython
if 'java' in sys.platform:
from javax.net.ssl import SSLContext
SSLContext.setDefault(TRUST_ALL_CONTEXT)
def getRequiredFieldNames(self):
return array((self.__timeAttrName, ), String)
def isThreadPoolExists(self, threadPoolName):
"""Does the given threadPool exist.
PARAMETERS:
threadPoolName -- name of the threadPool.
RETURN:
True if successful, or False.
"""
############################################################
# For all our configuration Objects within the scope,
# modify the attributes. Hopefully there is only one
# configuration Object. This depends on how the request
# was scoped.
############################################################
for configObject in self.configObjects:
self.debug(__name__ + ".isThreadPoolExists(): configObject=" +
str(configObject) + "\n")
self.debug(__name__ + ".isThreadPoolExists(): configObject type=" +
str(type(configObject)) + "\n")
########################################################
# Get the threadPools AttributeList
########################################################
pArgs = array(['threadPools'], java.lang.String)
myAttributeList = self.configService.getAttributes(
self.configService.session, configObject, pArgs, False)
self.debug(__name__ + ".isThreadPoolExists(): myAttributeList=" +
str(myAttributeList) + "\n")
self.debug(__name__ +
".isThreadPoolExists(): myAttributeList type=" +
str(type(myAttributeList)) + "\n")
myArrayList = self.configService.configServiceHelper.getAttributeValue(
myAttributeList, 'threadPools')
self.debug(__name__ + ".isThreadPoolExists(): myArrayList=" +
str(myArrayList) + "\n")
self.debug(__name__ + ".isThreadPoolExists(): myArrayList type=" +
str(type(myArrayList)) + "\n")
for myObject in myArrayList:
self.debug(__name__ + ".isThreadPoolExists(): myObject=" +
str(myObject) + "\n")
self.debug(__name__ + ".isThreadPoolExists(): myObject type=" +
str(type(myObject)) + "\n")
propertyAttributeList = self.configService.getAttributes(
self.configService.session, myObject, None, False)
for propAttr in propertyAttributeList:
propName = propAttr.getName()
propValue = propAttr.getValue()
self.debug(__name__ + ".isThreadPoolExists(): propName=" +
str(propName) + "\n")
#self.debug( __name__ + ".isThreadPoolExists(): propName type=" + str( type( propName ) ) + "\n" )
self.debug(__name__ + ".isThreadPoolExists(): propValue=" +
str(propValue) + "\n")
#self.debug( __name__ + ".isThreadPoolExists(): propValue type=" + str( type( propValue ) ) + "\n" )
if propName == 'name' and propValue == threadPoolName:
self.logIt(__name__ + ".isThreadPoolExists(): Found " +
str(propValue) + "\n")
return True
#Endif
#Endfor
#Endfor
#Endfor
self.logIt(__name__ + ".isThreadPoolExists(): " + str(threadPoolName) +
" not found." + "\n")
return False
def testFunc(self):
"""Do not use.
PARAMETERS:
RETURN:
True if successful, or False.
"""
rVal = True
############################################################
# For all our configuration Objects within the scope,
# modify the attributes. Hopefully there is only one
# configuration Object. This depends on how the request
# was scoped.
############################################################
for configObject in self.configObjects:
self.debug(__name__ + ".testFunc(): configObject=" +
str(configObject) + "\n")
self.debug(__name__ + ".testFunc(): configObject type=" +
str(type(configObject)) + "\n")
########################################################
# Get the classloaders AttributeList
########################################################
pArgs = array(['threadPools'], java.lang.String)
myAttributeList = self.configService.getAttributes(
self.configService.session, configObject, pArgs, False)
self.debug(__name__ + ".testFunc(): myAttributeList=" +
str(myAttributeList) + "\n")
self.debug(__name__ + ".testFunc(): myAttributeList type=" +
str(type(myAttributeList)) + "\n")
myArrayList = self.configService.configServiceHelper.getAttributeValue(
myAttributeList, 'threadPools')
self.debug(__name__ + ".testFunc(): myArrayList=" +
str(myArrayList) + "\n")
self.debug(__name__ + ".testFunc(): myArrayList type=" +
str(type(myArrayList)) + "\n")
for myObject in myArrayList:
self.debug(__name__ + ".testFunc(): myObject=" +
str(myObject) + "\n")
self.debug(__name__ + ".testFunc(): myObject type=" +
str(type(myObject)) + "\n")
propertyAttributeList = self.configService.getAttributes(
self.configService.session, myObject, None, False)
for propAttr in propertyAttributeList:
propName = propAttr.getName()
propValue = propAttr.getValue()
self.debug(__name__ + ".testFunc(): propName=" +
str(propName) + "\n")
#self.debug( __name__ + ".testFunc(): propName type=" + str( type( propName ) ) + "\n" )
self.debug(__name__ + ".testFunc(): propValue=" +
str(propValue) + "\n")
#self.debug( __name__ + ".testFunc(): propValue type=" + str( type( propValue ) ) + "\n" )
#Endfor
#Endfor
#self.debug( __name__ + ".testFunc(): BEFORE myAttributeList=" + str( myAttributeList ) + "\n" )
#self.debug( __name__ + ".testFunc(): BEFORE myAttributeList type=" + str( type( myAttributeList ) ) + "\n" )
#Endfor
#if rVal: self.refresh()
return rVal
def _java_array_byte(data):
return jarray.array(data, 'b')
def modifyThreadPool(
self,
name='WebContainer',
minimumSize=50,
maximumSize=50,
inactivityTimeout=6000,
isGrowable=True,
description='Modified by pylib.Was.ThreadPoolManager.'):
"""Modify the threadPool attributes for the given threadPool name.
PARAMETERS:
name -- ThreadPool name. Allows the thread pool to be given a name so that it can
be referenced in other places in the configuration. Not used for thread pool
instances contained directly under MessageListenerService, WebContainer,
ObjectRequestBroker.
minimumSize -- The minimum number of threads to allow in the pool.
maximumSize -- The maximum number of threads to allow in the pool.
inactivityTimeout -- The period of time in milliseconds after which a thread should be reclaimed due to inactivity.
isGrowable -- Allows the number of threads to increase beyond the maximum size configured for the thread pool.
description -- The description of the thread pool.
RETURN:
True if successful, or False.
"""
self.debug(__name__ + ".modifyThreadPool(): name=" + str(name) + "\n")
self.debug(__name__ + ".modifyThreadPool(): minimumSize=" +
str(minimumSize) + "\n")
self.debug(__name__ + ".modifyThreadPool(): maximumSize=" +
str(maximumSize) + "\n")
self.debug(__name__ + ".modifyThreadPool(): inactivityTimeout=" +
str(inactivityTimeout) + "\n")
self.debug(__name__ + ".modifyThreadPool(): isGrowable=" +
str(isGrowable) + "\n")
self.debug(__name__ + ".modifyThreadPool(): description=" +
str(description) + "\n")
rVal = False
############################################################
# For all our configuration Objects within the scope,
# modify the attributes. Hopefully there is only one
# configuration Object. This depends on how the request
# was scoped.
############################################################
for configObject in self.configObjects:
self.debug(__name__ + ".modifyThreadPool(): configObject=" +
str(configObject) + "\n")
self.debug(__name__ + ".modifyThreadPool(): configObject type=" +
str(type(configObject)) + "\n")
########################################################
# Get the threadPools AttributeList
########################################################
pArgs = array(['threadPools'], java.lang.String)
threadPoolsAttributeList = self.configService.getAttributes(
self.configService.session, configObject, pArgs, False)
#######################################################
# Go through each object in the list.
# Each myObject should be an Attribute() who's value
# is an ArrayList of AttributeList's.
#########################################################
for myObject in threadPoolsAttributeList:
self.debug(__name__ + ".modifyThreadPool(): myObject=" +
str(myObject) + "\n")
self.debug(__name__ + ".modifyThreadPool(): myObject type=" +
str(type(myObject)) + "\n")
#########################################################
# Get the list of the threadPools objects.
#########################################################
threadPoolConfigObjects = myObject.getValue()
self.debug(__name__ +
".modifyThreadPool(): threadPoolConfigObjects=" +
str(threadPoolConfigObjects) + "\n")
self.debug(
__name__ +
".modifyThreadPool(): threadPoolConfigObjects type=" +
str(type(threadPoolConfigObjects)) + "\n")
########################################################
# Go through the list of threadPools objects to
# find the match on the name and then modify it.
########################################################
if not isinstance(threadPoolConfigObjects,
java.util.ArrayList):
break
for threadPoolConfigObject in threadPoolConfigObjects:
self.debug(__name__ +
".modifyThreadPool(): threadPoolConfigObject=" +
str(threadPoolConfigObject) + "\n")
self.debug(
__name__ +
".modifyThreadPool(): threadPoolConfigObject type=" +
str(type(threadPoolConfigObject)) + "\n")
propertyAttributeList = self.configService.getAttributes(
self.configService.session, threadPoolConfigObject,
None, False)
threadName = self.configService.configServiceHelper.getAttributeValue(
propertyAttributeList, 'name')
###########################################################
# If the name does not match, then continue to the top
# of the loop.
###########################################################
if threadName != name: continue
self.debug(
__name__ +
".modifyThreadPool(): BEFORE propertyAttributeList=" +
str(propertyAttributeList) + "\n")
self.debug(
__name__ +
".modifyThreadPool(): BEFORE propertyAttributeList type="
+ str(type(propertyAttributeList)) + "\n")
#######################################################
# Set the threadPools AttributeList values.
#######################################################
#self.configService.configServiceHelper.setAttributeValue( propertyAttributeList, 'name', str( name ) )
self.configService.configServiceHelper.setAttributeValue(
propertyAttributeList, 'minimumSize', int(minimumSize))
self.configService.configServiceHelper.setAttributeValue(
propertyAttributeList, 'maximumSize', int(maximumSize))
self.configService.configServiceHelper.setAttributeValue(
propertyAttributeList, 'inactivityTimeout',
int(inactivityTimeout))
self.configService.configServiceHelper.setAttributeValue(
propertyAttributeList, 'isGrowable',
java.lang.Boolean(isGrowable))
self.configService.configServiceHelper.setAttributeValue(
propertyAttributeList, 'description', str(description))
self.debug(
__name__ +
".modifyThreadPool(): AFTER propertyAttributeList=" +
str(propertyAttributeList) + "\n")
####################################################################
# Save the threadPools attributes to the treadPoolConfigObject
# and the current session.
####################################################################
self.configService.setAttributes(
self.configService.session, threadPoolConfigObject,
propertyAttributeList)
rVal = True
break
#Endfor
#Endfor
#Endfor
if rVal: self.refresh()
return rVal
objectName = ObjectName("org.apache.cassandra.metrics:type=Keyspace,keyspace=ycsb,name=WriteLatency");
return(mBeanServerConnection.getAttribute(objectName,"Count"))
def WriteTotalLatency():
objectName = ObjectName("org.apache.cassandra.metrics:type=Keyspace,keyspace=ycsb,name=WriteTotalLatency");
return(mBeanServerConnection.getAttribute(objectName,"Count"))
def sig_handler(signal, frame):
fpath=os.path.join(opDir,filename)
with open(fpath, 'w') as f:
writer = csv.writer(f)
writer.writerows(output)
exit()
if __name__=='__main__':
signal.signal(signal.SIGINT, sig_handler)
credentials = array(["",""],String)
environment = {JMXConnector.CREDENTIALS:credentials}
if len(sys.argv[1:])==5:
serverUrl = sys.argv[1]
outputdir=sys.argv[2]
cores=sys.argv[3]
pid=sys.argv[4]
filename=sys.argv[5]
opDir=os.path.join(os.path.dirname(__file__),outputdir)
# if os.path.exists(opDir):
# shutil.rmtree(opDir)
# os.makedirs(opDir)
jmxServiceUrl = JMXServiceURL('service:jmx:rmi:///jndi/rmi://'+str(serverUrl)+':7199/jmxrmi');
jmxConnector = JMXConnectorFactory.connect(jmxServiceUrl,environment);
mBeanServerConnection = jmxConnector.getMBeanServerConnection()
print('started')
def tostring(self):
if jpython == 0:
return array.array("b", self.palette).tostring()
else:
return jarray.array(self.palette, "b").tostring()
def fact_i(num):
func_name = inspect.stack()[0][3]
MODULE_LOGGER.info(func_name + '()')
return _fact_i.invoke(JLong, jarray.array([num], JLong))
# Jython Dictionary
dict = {'011': 'New Delhi', '022': 'Mumbai', '033': 'Kolkata', 'Age': 25}
print("dict['011']: ", dict['011'])
print("dict['Age']: ", dict['Age'])
########################################################################################################################
import java.util.ArrayList as ArrayList
arr = ArrayList()
arr.add(10)
arr.add(20)
print("ArrayList: ", arr)
arr.remove(10) #remove 10 from arraylist
arr.add(0, 5) #add 5 at 0th index
print("ArrayList: ", arr)
print("element at index 1:", arr.get(1)) #retrieve item at index 1
arr.set(0,100) #set item at 0th index to 100
print("ArrayList: ", arr)
# Jarray Class
from jarray import array
my_seq = (1, 2, 3, 4, 5)
arr1 = array(my_seq, 'i')
print(arr1)
myStr = "Hello Jython"
arr2 = array(myStr, 'c')
print(arr2)
def fact_lp(num):
return _fact_lp.invoke(JLong, jarray.array([num], JLong))
from test_support import *
print_test('jarray module (test_jarray.py)', 1)
from jarray import array, zeros
print_test('array', 2)
from java import awt
hsb = awt.Color.RGBtoHSB(0, 255, 255, None)
#print hsb
assert hsb == array([0.5, 1, 1], 'f')
rgb = apply(awt.Color.HSBtoRGB, tuple(hsb))
#print hex(rgb)
assert rgb == 0xff00ffff
print_test('zeros', 2)
hsb1 = zeros(3, 'f')
awt.Color.RGBtoHSB(0, 255, 255, hsb1)
#print hsb, hsb1
assert hsb == hsb1
def pn_delivery(link, tag):
return wrap(link.impl.delivery(array(tag, 'b')), pn_delivery_wrapper)
def expt_i(base, num):
return _expt_i.invoke(JFloat, jarray.array([base, num], JFloat))
def _currentValues(self):
return array([
None if self.code == None else int(self.code),
None if self.name == None else unicode(self.name)
], Object)
''' @author: Francois Roewer-Despres ''' from artisynth.tools.batchsim.test import SimTaskRequester from jarray import array import sys args = array(sys.argv, String) worker = SimTaskRequester(args) worker.run() quit()
def get(self, index):
img = CellLoader.klb.readFull(timepoint_paths[index]).getImg()
# Each cell has "1" as its dimension in the last axis (time)
# and index as its min coordinate in the last axis (time)
return Cell(
Intervals.dimensionsAsIntArray(img) + array([1], 'i'),
Intervals.minAsLongArray(img) + array([index], 'l'),
extractArrayAccess(img))
# Load the first one, to read the dimensions and type (won't get cached unfortunately)
first = CellLoader.klb.readFull(timepoint_paths[0]).getImg()
pixel_type = first.randomAccess().get().createVariable()
# One cell per time point
dimensions = Intervals.dimensionsAsLongArray(first) + array(
[len(timepoint_paths)], 'l')
cell_dimensions = list(dimensions[0:-1]) + [
1
] # lists also work: will get mapped automatically to arrays
# The grid: how each independent stack fits into the whole continuous volume
grid = CellGrid(dimensions, cell_dimensions)
# Create the image cache (one 3D image per time point),
# which can load any Cell when needed using CellLoader
loading_cache = SoftRefLoaderCache().withLoader(CellLoader()).unchecked()
# Create a CachedCellImg: a LazyCellImg that caches Cell instances with a SoftReference, for best performance
# and also self-regulating regarding the amount of memory to allocate to the cache.
cachedCellImg = Factory().createWithCacheLoader(
dimensions, pixel_type, loading_cache,
def pn_link_send(link, bytes):
return link.impl.send(array(bytes, 'b'), 0, len(bytes))
def array(self, loc):
return array((loc.getFloatPosition(d)
for d in xrange(loc.numDimensions())), 'd')
pref.setLogFileName(sys.argv[4])
pref.setUserId(sys.argv[2])
pref.setRefreshRate(int(sys.argv[5]))
pref.setBufferSize(int(sys.argv[6]))
pref.setNumLogFiles(int(sys.argv[7]))
pref.setLogFileSize(int(sys.argv[8]))
pref.setLoggingDuration(int(sys.argv[9]))
pref.setTpvLogFormat(sys.argv[10])
list_p = java.util.ArrayList()
list_p.add(pref)
params = jarray.array(list_p, java.lang.Object)
list_s = java.util.ArrayList()
list_s.add("com.ibm.ws.tpv.engine.UserPreferences")
sigs = jarray.array(list_s, java.lang.String)
#Start Monitoring Server#
AdminControl.invoke_jmx(tpvOName, "monitorServer", params, sigs)
#Logging Functionality#
AdminControl.invoke_jmx(tpvOName, sys.argv[11] + "Logging", params, sigs)
lambda s: symbol(s.toString()),
UnsignedInteger:
lambda n: n.longValue(),
UnsignedLong:
lambda n: n.longValue()
}
conversions_PY2J = {
dict:
lambda d: dict([(PY2J(k), PY2J(v)) for k, v in d.items()]),
list:
lambda l: [PY2J(x) for x in l],
symbol:
lambda s: Symbol.valueOf(s),
Array:
lambda a: array(map(arrayElementMappings[a.type], a.elements),
arrayTypeMappings[a.type])
}
def identity(x):
return x
def J2PY(obj):
result = conversions_J2PY.get(type(obj), identity)(obj)
return result
def PY2J(obj):
result = conversions_PY2J.get(type(obj), identity)(obj)
return result
def run():
myPrint("=== bConcatALign ===")
#get source folder
if len(sys.argv) < 2:
#from user
sourceFolder = DirectoryChooser("Please Choose A Directory Of .tif Files").getDirectory()
if not sourceFolder:
myPrint(' Aborted by user')
return
else:
#from command line
sourceFolder = sys.argv[1] #assuming it ends in '/'
destFolder = sourceFolder + "channels8/"
#a list of file names
fileList = []
sliceList = []
timeseries = []
#ccc = Concatenator()
#i = 0
for filename in os.listdir(sourceFolder):
startWithDot = filename.startswith(".")
isMax = filename.endswith("max.tif")
isTif = filename.endswith(".tif")
if (not startWithDot) and (not isMax) and (isTif):
myPrint(filename)
fullPath = sourceFolder + filename
shortName, fileExtension = os.path.splitext(filename)
fileList.append(filename)
#get x/y/z dims and append to list
#imp = Opener.openUsingBioFormats(fullPath) #not working
imp = IJ.openImage(sourceFolder + filename)
imp.setOpenAsHyperStack(False)
timeseries.append(imp)
#if (i==0):
# mergedImp = imp
#else:
# print i
# ccc.concatenate(mergedImp, imp, True)
#
#i += 1
calib = timeseries[0].getCalibration()
dimA = timeseries[0].getDimensions()
#why doesn't this f*****g work !!!!!!!!!!!!!!!!!!
#infoProp = timeseries[0].getInfoProperty()
#print calib
#print dimA
#print infoProp
jaimp = array(timeseries, ImagePlus)
ccc = Concatenator()
allimp = ccc.concatenate(jaimp, False)
#allimp.setDimensions(dimA[2], dimA[3], len(GRlist))
allimp.setCalibration(calib)
allimp.setOpenAsHyperStack(True)
allimp.show()
def converToByteArray(self):
tPic = open('image.jpg.1', 'rb')
byteImg = array(tPic.read(), 'b')
tPic.close()
return byteImg
def deleteThreadPool(self, name='DCSChannel'):
"""Delete the threadPool for the given threadPool name.
PARAMETERS:
name -- ThreadPool name. Allows the thread pool to be given a name so that it can
be referenced in other places in the configuration. Not used for thread pool
instances contained directly under MessageListenerService, WebContainer,
ObjectRequestBroker.
RETURN:
True if successful, or False.
"""
self.debug(__name__ + ".deleteThreadPool(): name=" + str(name) + "\n")
rVal = False
############################################################
# For all our configuration Objects within the scope,
# modify the attributes. Hopefully there is only one
# configuration Object. This depends on how the request
# was scoped.
############################################################
for configObject in self.configObjects:
self.debug(__name__ + ".deleteThreadPool(): configObject=" +
str(configObject) + "\n")
self.debug(__name__ + ".deleteThreadPool(): configObject type=" +
str(type(configObject)) + "\n")
########################################################
# Get the threadPools AttributeList
########################################################
pArgs = array(['threadPools'], java.lang.String)
threadPoolsAttributeList = self.configService.getAttributes(
self.configService.session, configObject, pArgs, False)
#######################################################
# Go through each object in the list.
# Each myObject should be an Attribute() who's value
# is an ArrayList of AttributeList's.
#########################################################
for myObject in threadPoolsAttributeList:
self.debug(__name__ + ".deleteThreadPool(): myObject=" +
str(myObject) + "\n")
self.debug(__name__ + ".deleteThreadPool(): myObject type=" +
str(type(myObject)) + "\n")
#########################################################
# Get the list of the threadPools objects.
#########################################################
threadPoolConfigObjects = myObject.getValue()
self.debug(__name__ +
".deleteThreadPool(): threadPoolConfigObjects=" +
str(threadPoolConfigObjects) + "\n")
self.debug(
__name__ +
".deleteThreadPool(): threadPoolConfigObjects type=" +
str(type(threadPoolConfigObjects)) + "\n")
########################################################
# Go through the list of threadPools objects to
# find the match on the name and then modify it.
########################################################
if not isinstance(threadPoolConfigObjects,
java.util.ArrayList):
break
for threadPoolConfigObject in threadPoolConfigObjects:
self.debug(__name__ +
".deleteThreadPool(): threadPoolConfigObject=" +
str(threadPoolConfigObject) + "\n")
self.debug(
__name__ +
".deleteThreadPool(): threadPoolConfigObject type=" +
str(type(threadPoolConfigObject)) + "\n")
propertyAttributeList = self.configService.getAttributes(
self.configService.session, threadPoolConfigObject,
None, False)
threadName = self.configService.configServiceHelper.getAttributeValue(
propertyAttributeList, 'name')
###########################################################
# If the name does not match, then continue to the top
# of the loop.
###########################################################
if threadName != name: continue
self.configService.deleteConfigData(
self.configService.session, threadPoolConfigObject)
self.logIt(__name__ + ".deleteThreadPool(): Deleted =" +
str(name) + "\n")
self.logIt(__name__ +
".deleteThreadPool(): threadPoolConfigObject=" +
str(threadPoolConfigObject) + "\n")
rVal = True
break
#Endfor
#Endfor
#Endfor
if rVal: self.refresh()
return rVal
"""
Check an array can be created from a string.
"""
import support
from jarray import array
s = "abcdef"
try:
a = array(s, 'b')
except TypeError, e:
raise support.TestWarning(
"I think an ascii string should be auto converted to a byte array")
