def get_response(self):
"""Return the file like 'f' that leo_interface.send_head makes"""
if self.request_handler.path.startswith('/_/add/bkmk/'):
return self.add_bookmark()
f = StringIO()
f.write("Unknown URL in LeoActions.get_response()")
return f
def generate_csv(data):
output_csv = StringIO()
csv_writer = csv.writer(output_csv)
header = ["identifiant", "date", "montant", "type", "acheteur", "activité", "description", "fournisseur", "autorisation", "décision", "dossier" ]
csv_writer.writerow(header)
yield output_csv.getvalue()
for release in data["releases"]:
output_csv = StringIO()
csv_writer = csv.writer(output_csv)
laliste = []
laliste.append(release["ocid"])
laliste.append(release["date"][0:10])
laliste.append(release["awards"][0]["value"]["amount"])
laliste.append(release["tender"]["procurementMethodRationale"])
laliste.append(release["buyer"]["name"])
laliste.append(", ".join(release["subject"]))
laliste.append(release["awards"][0]["items"][0]["description"])
laliste.append(release["awards"][0]["suppliers"][0]["name"])
laliste.append(release["tender"]["procuringEntity"]["name"])
laliste.append(release["awards"][0]["items"][0]["id"])
laliste.append(release["awards"][0]["id"])
csv_writer.writerow(laliste)
yield output_csv.getvalue()
def _write(self, string):
stringio._complain_ifclosed(self.closed)
if '\n' in string:
self._wrote_newline = True
else:
self._wrote_newline = False
stringio.StringIO.write(self, string)
def generate_xlsx(data):
output_xlsx = StringIO()
workbook = xlsxwriter.Workbook(output_xlsx)
worksheet = workbook.add_worksheet()
header = ["identifiant", "date", "montant", "type", "acheteur", "activité", "description", "fournisseur", "autorisation", "décision", "dossier" ]
[worksheet.write(0, col, val) for (col, val) in enumerate(header) ]
col = 0
row = 1
for release in data["releases"]:
worksheet.write(row, col, release["ocid"])
worksheet.write(row, col+1, release["date"][0:10])
worksheet.write(row, col+2, release["awards"][0]["value"]["amount"])
worksheet.write(row, col+3, release["tender"]["procurementMethodRationale"])
worksheet.write(row, col+4, release["buyer"]["name"])
worksheet.write(row, col+5, ", ".join(release["subject"]))
worksheet.write(row, col+6, release["awards"][0]["items"][0]["description"])
worksheet.write(row, col+7, release["awards"][0]["suppliers"][0]["name"])
worksheet.write(row, col+8, release["tender"]["procuringEntity"]["name"])
worksheet.write(row, col+9, release["awards"][0]["items"][0]["id"])
worksheet.write(row, col+10, release["awards"][0]["id"])
row += 1
workbook.close()
return output_xlsx.getvalue()
def openUrl(url, fresh=False, default="{}"):
global nocache
if fresh == True:
return urllib2.urlopen(getUrlRequest(url))
f = "%s.html" % hashlib.sha224(url).hexdigest()
if os.path.exists(os.path.join("cache", f)) and nocache == False:
if os.path.getmtime(os.path.join("cache", f)) > time.time() - (60 * 60 * 1):
return open(os.path.join("cache", f), "r")
c = open(os.path.join("cache", f), "w")
try:
u = urllib2.urlopen(getUrlRequest(url))
c.write(u.read())
u.close()
c.close()
if nocache == True:
return open(os.path.join("cache", f), "r")
else:
return openUrl(url)
except Exception as ex:
c.seek(0)
c.write(default)
c.close()
o = StringIO()
o.write(default)
o.seek(0)
return o
def pretty_print_string(description):
"""
Generates a pretty print string for a description.
"""
stream = StringIO()
pretty_print(description, stream)
return stream.getvalue()
def request(self, url, method, data, headers):
self.requestheaders = headers
from StringIO import StringIO
response = StringIO('Body Text')
response.getheaders = lambda: {'h1':1,'h2':2}
return response
def test_logging_setup_with_config_obj(self):
class RootController(object):
@expose()
def index(self):
import logging
logging.getLogger('pecantesting').info('HELLO WORLD')
return "HELLO WORLD"
from cStringIO import StringIO
f = StringIO()
from pecan.configuration import conf_from_dict
app = TestApp(make_app(RootController(), logging=conf_from_dict({
'loggers': {
'pecantesting': {
'level': 'INFO', 'handlers': ['memory']
}
},
'handlers': {
'memory': {
'level': 'INFO',
'class': 'logging.StreamHandler',
'stream': f
}
}
})))
app.get('/')
assert f.getvalue() == 'HELLO WORLD\n'
def save(filename, extra_info='',
file=file, StringIO=cStringIO.StringIO, #@ReservedAssignment
mutate_flag=False, wait=None):
"""
:doc: loadsave
:args: (filename, extra_info='')
Saves the game state to a save slot.
`filename`
A string giving the name of a save slot. Despite the variable name,
this corresponds only loosely to filenames.
`extra_info`
An additional string that should be saved to the save file. Usually,
this is the value of :var:`save_name`.
:func:`renpy.take_screenshot` should be called before this function.
"""
cache.pop(filename, None)
filename = filename + savegame_suffix
try:
os.unlink(renpy.config.savedir + "/" + filename)
except:
pass
if mutate_flag:
renpy.python.mutate_flag = False
roots = renpy.game.log.freeze(wait)
logf = StringIO()
dump((roots, renpy.game.log), logf)
if mutate_flag and renpy.python.mutate_flag:
raise SaveAbort()
if renpy.config.save_dump:
save_dump(roots, renpy.game.log)
rf = file(renpy.config.savedir + "/" + filename, "wb")
zf = zipfile.ZipFile(rf, "w", zipfile.ZIP_DEFLATED)
# Screenshot.
zf.writestr("screenshot.png", renpy.game.interface.get_screenshot())
# Extra info.
zf.writestr("extra_info", extra_info.encode("utf-8"))
# Version.
zf.writestr("renpy_version", renpy.version)
# The actual game.
zf.writestr("log", logf.getvalue())
zf.close()
rf.close()
def test_unquoted_key_state_without_whitespace(self):
io = StringIO()
uks = UnquotedKeyState(io)
for c in 'hello_world':
self.assertFalse(uks.character(c))
self.assertTrue(uks.character('='))
self.assertEquals('hello_world', io.getvalue())
def generar_pdf_view(request,pk):
canino = Canino.objects.filter(id = int(pk))
serovares = Serovar.objects.all()
result = StringIO()
template = get_template("home/reporte.html")
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath('images/facultad.jpg')))
BASE_DIR += '/vete/static/images/'
facultad_image = BASE_DIR + 'facultad.jpg'
unlp_image = BASE_DIR + 'unlp.jpg'
punta_indio_image = BASE_DIR + 'punta_indio.jpg'
data = {
'pagesize':'A4',
'title':'Reporte',
'canino':canino[0],
'facultad_image':facultad_image,
'unlp_image':unlp_image,
'punta_indio_image':punta_indio_image,
'serovares':serovares,
}
context = Context(data)
html = template.render(context)
pdf = pisa.pisaDocument(StringIO( "{0}".format(html.encode('ascii','ignore')) ), result)
if not pdf.err:
return http.HttpResponse(
result.getvalue(),
content_type='application/pdf')
return http.HttpResponse('We had some errors')
def WriteTile(self, level, row, col, data):
# 写入瓦片数据
name = self.GetBundleName(level, row, col)
bundlename = os.path.join(self.tiledir, name + '.bundle')
basedir = os.path.dirname(bundlename)
if (os.path.exists(basedir) == False):
os.makedirs(basedir)
if bundlename not in self.bundles.keys():
self.bundles[bundlename] = BundleClass(bundlename)
bundle_class = self.bundles[bundlename]
if (os.path.exists(bundlename) == False):
# 创建新的瓦片集
startrow, startcol = self.GetBundleRowCol(row, col)
bundle_class.CreateNew(startrow, startcol)
# 压缩数据
buf = StringIO()
gzip.GzipFile(mode='wb', fileobj=buf).write(data)
zdata = buf.getvalue()
# 插入瓦片
bundle_class.InsertData(zdata, row, col)
def getText(self, fid = None):
if fid:
self.xmlf.getText(fid)
else:
sfid = StringIO()
self.xmlf.getText(sfid)
return sfid.getvalue()
def generate_topart(nick, period, width, height):
size = config.ABOUT_ME_WIDTH // width
req_size = opt_size(size)
error = ''
topart = None
images, error = get_arts_images(nick, period, width * height, req_size)
if images and not error:
if len(images) < width * height:
if len(images) >= width:
height = len(images) // width
images = images[:width * height]
else:
height = 1
width = len(images)
canvas = Image.new('RGBA', (size * width, size * height))
for index, image in enumerate(images):
append_image(canvas, image, index, width, size)
output = StringIO()
canvas.save(output, format="PNG")
topart = output.getvalue()
output.close()
else:
error = 'Topart generation failed'
return topart, error
class StorageFile(File):
def __init__(self, name, mode, storage):
self.name = name
self.mode = mode
self.file = StringIO.StringIO()
self._storage = storage
self._is_dirty = False
@property
def size(self):
if hasattr(self, '_size'):
self._size = self.storage.size(self.name)
return self._size
def read(self, num_bytes=None):
if not hasattr(self, '_obj'):
self._obj = self._storage._open_read(self.name)
return self._obj.read(num_bytes)
def write(self, content):
if 'w' not in self._mode:
raise AttributeError("File was opened for read-only access.")
self.file = StringIO(content)
self._is_dirty = True
def close(self):
if self._is_dirty:
self._storage._save(self.name, self.file.getvalue())
self.file.close()
def test_upload(self):
c = Client()
url = reverse('gbd.covariate_data_server.views.covariate_upload')
response = c.get(url)
self.assertRedirects(response, '/accounts/login/?next=%s'%url)
# then login and do functional tests
c.login(username='******', password='******')
response = c.get(url)
self.assertTemplateUsed(response, 'covariate_upload.html')
response = c.post(url, {})
self.assertTemplateUsed(response, 'covariate_upload.html')
# now do it right, and make sure that data and datasets are added
from StringIO import StringIO
f = StringIO(',iso3,year,LDI_id,LDI_usd\n1,ABW,1950,1533.743774,1105.747437\n1,ABW,1951,1533.843774,1105.87437\n')
f.name = 'LDI.csv'
response = c.post(url, {'file':f, 'type': 'LDI_id', 'source': 'web', 'notes': 'description', 'uploader': 'red', 'yearStart': 1950, 'yearEnd': 2010})
self.assertRedirects(response, reverse('gbd.covariate_data_server.views.covariate_type_list_show'))
self.assertEqual(CovariateType.objects.filter(slug='LDI_id').count(), 1)
self.assertEqual(Covariate.objects.filter(type__slug='LDI_id', sex='male').count(), 2)
self.assertEqual(Covariate.objects.filter(type__slug='LDI_id', sex='female').count(), 2)
self.assertEqual(Covariate.objects.filter(type__slug='LDI_id', sex='total').count(), 2)
def request(self, url, method, data, headers):
self.requestheaders = headers
from StringIO import StringIO
response = StringIO('<html><head><title>My Message Manager</title></head><body><p>Jalani Bakari, you are signed in (Residential)!</body></html>')
response.getheaders = lambda: {'set-cookie':'sid=12345abcde'}
return response
def _generatePDF(write_file=False, title="Latest CCOL Events", school_id="", grade="", subject=""):
events = Event.objects.all().order_by('-start_date')[:4]
context_dict = {'events':events,
'title':title}
template = get_template("flyer_pdf.html")
context = Context(context_dict)
html = template.render(context)
result = StringIO()
pdf = pisa.pisaDocument(StringIO( "{0}".format(html) ), result)
if not pdf.err:
if write_file:
tempFileName = settings.MEDIA_ROOT+"/"+title.replace(" ","")+".pdf"
tempFile = open(tempFileName, 'wb+')
tempFile.write(result.getvalue())
tempFile.close()
return tempFileName
else:
return HttpResponse(result.getvalue(), content_type='application/pdf')
if write_file:
return None
return HttpResponse('We had some errors<pre>%s</pre>' % cgi.escape(html))
def request(self, url, method, data, headers):
self.requestheaders = headers
from StringIO import StringIO
response = StringIO('<html><head><title>Reservation Manager</title></head><body><p>Jalani Bakari, you are signed in (Residential)!</body></html>')
response.getheaders = lambda: {}
return response
def unpack(self):
"""
Unpacks bytes from messagepack into key-value pair data
in a dictionary; extract sender. Looks for some optional special fields:
sender: a string labeling the sender; choosing a unique id is sender's responsibility
shotnumber: an integer representing the shotnumber
repnumber: an integer representing the repetition number
onunpack: a string of python commands to execute on unpack
"""
self.data=msgpack.unpackb(self.messagepack)
notify_data_elms=['sender','shotnumber','repnumber']
self.notify_data={}
for elm in notify_data_elms:
try: self.notify_data.update({elm:self.data[elm]})
except KeyError: pass
try:
self.unpack_instructions=self.data['onunpack']
try:
rbuffer = StringIO()
sys.stdout = rbuffer
exec(self.unpack_instructions,self.data)
if self.data.has_key('__builtins__'):
del self.data['__builtins__']
sys.stdout = sys.__stdout__
self.data.update({"onunpack_response":rbuffer.getvalue()})
except: self.data.update({"onunpack_error":True})
except KeyError: pass
def __str__(self):
self.process()
f = StringIO()
self.battles.write(f)
f.reset()
return ''.join(f.readlines())
def main():
global b64str
cpimage = clipboard.get_image()
#if image was in clipboard.
if cpimage:
#resize to icon size.
icon = cpimage.resize((57, 57), Image.BILINEAR)
#convert to rgb format.
icon = icon.convert('RGB')
# icon.show() #show resized image.
#create string buffer to write png file to.
iconstr = StringIO()
#write image to string buffer in png format.
icon.save(iconstr, 'png')
#convert save buffer to base64.
b64str = base64.standard_b64encode(iconstr.getvalue())
#put base64 string in clipboard.
clipboard.set(b64str)
#now decode to test.
mystr = base64.standard_b64decode(b64str)
#read file from string buffer.
stb = StringIO(mystr)
img = Image.open(stb)
#show the image.
img.show()
#print some info.
print str(img.format)
print str(img.mode)
print str(img.size)
print str(img.info)
class TestWriter(unittest.TestCase):
def setUp(self):
self.io = StringIO()
self.writer = excelcsv.writer(self.io)
def tearDown(self):
self.io.close()
def test_write(self):
self.writer.writerow([u'a', u'b', u'c'])
self.writer.writerow([u'd', u'e', u'f'])
value = self.io.getvalue()
self.assertIsInstance(value, text_type)
self.assertEqual(value, u'a,b,c\r\nd,e,f\r\n')
def test_writerows(self):
self.writer.writerows([
[u'a', u'b', u'c'],
[u'd', u'e', u'f'],
])
value = self.io.getvalue()
self.assertIsInstance(value, text_type)
self.assertEqual(value, u'a,b,c\r\nd,e,f\r\n')
def test_read_ok(self):
ptt_fh = StringIO()
print >>ptt_fh, """Listeria monocytogenes EGD-e, complete genome - 1..2944528
2 proteins
Location Strand Length PID Gene Synonym Code COG Product
318..1673 + 451 16802049 dnaA lmo0001 - COG0593L chromosomal replication initiation protein
4644..4865 - 73 16802052 - lmo0004 - - -
"""
expected_dict = { "lmo0001" :{ "start" : 318,
"end" : 1673,
"strand" : "+",
"PID" : "16802049",
"gene" : "dnaA",
"COG" : "COG0593L",
"product" : "chromosomal replication initiation protein"},
"lmo0004" : {"start" : 4644,
"end" : 4865,
"strand" : "-",
"PID" : "16802052",
"gene" : "",
"COG" : "",
"product" : ""}
}
ptt_fh.seek(0,0)
reader = PTTReader()
result_dict = reader.read_and_check(ptt_fh)
self.assertEquals(expected_dict, result_dict)
def to_string(self, endpoints):
"""
Converts the given endpoint description beans into a string
:param endpoints: A list of EndpointDescription beans
:return: A string containing an XML document
"""
# Make the ElementTree
root = self._make_xml(endpoints)
tree = ElementTree.ElementTree(root)
# Force the default name space
ElementTree.register_namespace("", EDEF_NAMESPACE)
# Make the XML
for encoding in ('unicode', 'UTF-8'):
# Prepare a StringIO output
output = StringIO()
try:
# Try to write with a correct encoding
tree.write(output, encoding=encoding, xml_declaration=True,
method="xml")
break
except LookupError:
# 'unicode' is needed in Python 3, but unknown in Python 2...
continue
else:
raise LookupError("Couldn't find a valid encoding")
return output.getvalue()
def uploadWorkboxImage(request):
if request.method == 'POST':
userInfo_id = request.POST["userInfo_id"]
project_id = request.POST["project_id"]
inputNumber = request.POST["inputNumber"]
myfile = request.POST["file"]
userInfo = UserInfo.objects.get(id=userInfo_id)
if Project.objects.filter(id=project_id):
project = Project.objects.get(id=project_id)
file_path = os.path.join(settings.ROOT_PATH,'media', request.user.first_name+request.user.last_name+str(request.user.id), str(project.title[:5]+str(project.id)))
make_sure_path_exists(file_path)
workBox = StringIO()
image_string = StringIO(base64.b64decode(myfile))
image = Image.open(image_string)
image.save(workBox, 'JPEG', quality=40)
workBox.seek(0)
outfile = open(os.path.join(file_path,'workBoxImage'+str(inputNumber)+'.jpg'),'wb')
outfile.write(workBox.getvalue())
outfile.close()
newPath = '/media/'+request.user.first_name+request.user.last_name+str(request.user.id)+'/'+ str(project.title[:5]+str(project.id))+'/'+'workBoxImage'+str(inputNumber)+'.jpg'
#record my answer
if MyAnswer.objects.filter(userInfo=userInfo, answerId=inputNumber):
myAnswerObject = MyAnswer.objects.get(userInfo=userInfo, answerId=inputNumber)
myAnswerObject.workImagePath = newPath
myAnswerObject.save()
else:
myAnswerObject = MyAnswer.objects.create(
project = project,
userInfo=userInfo,
answerId = inputNumber,
workImagePath = newPath,
)
data = {
'success': "Image Saved.",
'file': myfile,
}
else:
data = {
'error': "There is no project with that ID.",
}
else:
data = {
'error': "There was an error posting this request. Please try again.",
}
return HttpResponse(json.dumps(data))
def peek(self, n):
StringIO._complain_ifclosed(self.closed)
if self.buflist:
self.buf += ''.join(self.buflist)
self.buflist = []
newpos = min(self.pos+n, self.len)
r = self.buf[self.pos:newpos]
return r
def Save_traj(bin_num,traj_property,plan): file_name = "Traj/bin_"+ str(bin_num) +"/"+ str(traj_property); print "saving bin.",bin_num,"trajectory to file",file_name; buf = StringIO(); plan.serialize(buf); f = open(file_name,"w"); f.write(buf.getvalue()); f.close();
def Save_traj(file_name,plan):
print "saving ",file_name;
buf = StringIO();
plan.serialize(buf);
f = open(file_name,"w");
f.write(buf.getvalue());
f.close();
def serve_itemcsv(filename):
mdf = month_by_owner_item(filename)
buffer = StringIO()
mdf.to_csv(buffer,encoding='utf-8')
buffer.seek(0)
return send_file(buffer,
attachment_filename="test.csv",
mimetype='text/csv')
def GenFmpCapsule(self):
#
# Generate capsule header
# typedef struct {
# EFI_GUID CapsuleGuid;
# UINT32 HeaderSize;
# UINT32 Flags;
# UINT32 CapsuleImageSize;
# } EFI_CAPSULE_HEADER;
#
Header = StringIO.StringIO()
#
# Use FMP capsule GUID: 6DCBD5ED-E82D-4C44-BDA1-7194199AD92A
#
Header.write(
PackRegistryFormatGuid('6DCBD5ED-E82D-4C44-BDA1-7194199AD92A'))
HdrSize = 0
if 'CAPSULE_HEADER_SIZE' in self.TokensDict:
Header.write(
pack('=I', int(self.TokensDict['CAPSULE_HEADER_SIZE'], 16)))
HdrSize = int(self.TokensDict['CAPSULE_HEADER_SIZE'], 16)
else:
Header.write(pack('=I', 0x20))
HdrSize = 0x20
Flags = 0
if 'CAPSULE_FLAGS' in self.TokensDict:
for flag in self.TokensDict['CAPSULE_FLAGS'].split(','):
flag = flag.strip()
if flag == 'PopulateSystemTable':
Flags |= 0x00010000 | 0x00020000
elif flag == 'PersistAcrossReset':
Flags |= 0x00010000
elif flag == 'InitiateReset':
Flags |= 0x00040000
Header.write(pack('=I', Flags))
#
# typedef struct {
# UINT32 Version;
# UINT16 EmbeddedDriverCount;
# UINT16 PayloadItemCount;
# // UINT64 ItemOffsetList[];
# } EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER;
#
FwMgrHdr = StringIO.StringIO()
if 'CAPSULE_HEADER_INIT_VERSION' in self.TokensDict:
FwMgrHdr.write(
pack('=I',
int(self.TokensDict['CAPSULE_HEADER_INIT_VERSION'], 16)))
else:
FwMgrHdr.write(pack('=I', 0x00000001))
FwMgrHdr.write(
pack('=HH', len(self.CapsuleDataList), len(self.FmpPayloadList)))
FwMgrHdrSize = 4 + 2 + 2 + 8 * (len(self.CapsuleDataList) +
len(self.FmpPayloadList))
#
# typedef struct _WIN_CERTIFICATE {
# UINT32 dwLength;
# UINT16 wRevision;
# UINT16 wCertificateType;
# //UINT8 bCertificate[ANYSIZE_ARRAY];
# } WIN_CERTIFICATE;
#
# typedef struct _WIN_CERTIFICATE_UEFI_GUID {
# WIN_CERTIFICATE Hdr;
# EFI_GUID CertType;
# //UINT8 CertData[ANYSIZE_ARRAY];
# } WIN_CERTIFICATE_UEFI_GUID;
#
# typedef struct {
# UINT64 MonotonicCount;
# WIN_CERTIFICATE_UEFI_GUID AuthInfo;
# } EFI_FIRMWARE_IMAGE_AUTHENTICATION;
#
# typedef struct _EFI_CERT_BLOCK_RSA_2048_SHA256 {
# EFI_GUID HashType;
# UINT8 PublicKey[256];
# UINT8 Signature[256];
# } EFI_CERT_BLOCK_RSA_2048_SHA256;
#
PreSize = FwMgrHdrSize
Content = StringIO.StringIO()
for driver in self.CapsuleDataList:
FileName = driver.GenCapsuleSubItem()
FwMgrHdr.write(pack('=Q', PreSize))
PreSize += os.path.getsize(FileName)
File = open(FileName, 'rb')
Content.write(File.read())
File.close()
for fmp in self.FmpPayloadList:
if fmp.ImageFile:
for Obj in fmp.ImageFile:
fmp.ImageFile = Obj.GenCapsuleSubItem()
if fmp.VendorCodeFile:
for Obj in fmp.VendorCodeFile:
fmp.VendorCodeFile = Obj.GenCapsuleSubItem()
if fmp.Certificate_Guid:
ExternalTool, ExternalOption = FindExtendTool(
[], GenFdsGlobalVariable.ArchList, fmp.Certificate_Guid)
CmdOption = ''
CapInputFile = fmp.ImageFile
if not os.path.isabs(fmp.ImageFile):
CapInputFile = os.path.join(
GenFdsGlobalVariable.WorkSpaceDir, fmp.ImageFile)
CapOutputTmp = os.path.join(GenFdsGlobalVariable.FvDir,
self.UiCapsuleName) + '.tmp'
if ExternalTool == None:
EdkLogger.error(
"GenFds", GENFDS_ERROR,
"No tool found with GUID %s" % fmp.Certificate_Guid)
else:
CmdOption += ExternalTool
if ExternalOption:
CmdOption = CmdOption + ' ' + ExternalOption
CmdOption += ' -e ' + ' --monotonic-count ' + str(
fmp.MonotonicCount
) + ' -o ' + CapOutputTmp + ' ' + CapInputFile
CmdList = CmdOption.split()
GenFdsGlobalVariable.CallExternalTool(
CmdList, "Failed to generate FMP auth capsule")
if uuid.UUID(fmp.Certificate_Guid) == EFI_CERT_TYPE_PKCS7_GUID:
dwLength = 4 + 2 + 2 + 16 + os.path.getsize(
CapOutputTmp) - os.path.getsize(CapInputFile)
else:
dwLength = 4 + 2 + 2 + 16 + 16 + 256 + 256
fmp.ImageFile = CapOutputTmp
AuthData = [
fmp.MonotonicCount, dwLength, WIN_CERT_REVISION,
WIN_CERT_TYPE_EFI_GUID, fmp.Certificate_Guid
]
Buffer = fmp.GenCapsuleSubItem(AuthData)
else:
Buffer = fmp.GenCapsuleSubItem()
FwMgrHdr.write(pack('=Q', PreSize))
PreSize += len(Buffer)
Content.write(Buffer)
BodySize = len(FwMgrHdr.getvalue()) + len(Content.getvalue())
Header.write(pack('=I', HdrSize + BodySize))
#
# The real capsule header structure is 28 bytes
#
Header.write('\x00' * (HdrSize - 28))
Header.write(FwMgrHdr.getvalue())
Header.write(Content.getvalue())
#
# Generate FMP capsule file
#
CapOutputFile = os.path.join(GenFdsGlobalVariable.FvDir,
self.UiCapsuleName) + '.Cap'
SaveFileOnChange(CapOutputFile, Header.getvalue(), True)
return CapOutputFile
def create_doc(file_name, details=False):
doctype = "<!DOCTYPE html><html></html>"
tree = etree.parse(StringIO(doctype))
header = etree.SubElement(tree.getroot(), "head")
if details:
meta = etree.SubElement(header, "meta")
meta.set("name","pdfkit-orientation")
meta.set("content", "Landscape")
link = etree.SubElement(header, "link")
link.set("rel","stylesheet")
link.set("href", "../helper/style.css")
body = etree.SubElement(tree.getroot(), "body")
script = etree.SubElement(body, "script")
script.set("src", "https://s3-us-west-2.amazonaws.com/s.cdpn.io/3/modernizr-2.7.1.js")
cases = ExperimentsOverview.getTestCases()
for case in cases:
if details:
table = etree.SubElement(body, "table")
table.set("class", "table")
table.set("width", "1024px")
caption = etree.SubElement(table,"caption")
h1 = etree.SubElement(caption, "h1")
h1.text = case[0]
thead = etree.SubElement(table, "thead")
comments = ExperimentsOverview.getTestCaseComments(case[0])
tr = etree.SubElement(thead, "tr")
th = etree.SubElement(tr, "th")
th.text = "device"
br = etree.SubElement(th,"br")
br.tail = "package"
th = etree.SubElement(tr, "th")
th.text = "comment"
for comment in comments:
if int(comment[1]) in devices:
tr = etree.SubElement(table, "tr")
th = etree.SubElement(tr, "th")
th.text = comment[2]
br = etree.SubElement(th, "br")
br.tail = comment[0]
th.set("class","row-header")
td = etree.SubElement(tr, "td")
td.text = comment[3]
table = etree.SubElement(body, "table")
if not details:
table.set("class","table table-header-rotated")
else:
table.set("class", "table")
caption = etree.SubElement(table,"caption")
h1 = etree.SubElement(caption, "h1")
h1.text = case[0]
thead = etree.SubElement(table, "thead")
steps = ExperimentsOverview.getTestSteps(case[0])
tr = etree.SubElement(thead, "tr")
th = etree.SubElement(tr, "th")
th.text = "test step"
th = etree.SubElement(tr, "th")
th.text = "rating"
th.set("width", "200px")
th = etree.SubElement(tr, "th")
th.text = "desc"
th.set("width", "200px")
devicenames = Devices.getDevicesNames(devices)
for device in devicenames:
th = etree.SubElement(tr, "th")
div = etree.SubElement(th, "div")
span = etree.SubElement(div, "span")
span.text = device[0]
br = etree.SubElement(span, "br")
br.tail = device[1]
th.set("class","rotate")
tbody = etree.SubElement(table, "tbody")
for step in steps:
tr = etree.SubElement(tbody, "tr")
th = etree.SubElement(tr, "th")
th.text = step[0]
th.set("class","row-header")
td2 = etree.SubElement(tr, "td")
td2.text = step[1]
td2.set("style", "font-size: small;")
td3 = etree.SubElement(tr, "td")
td3.text = step[2]
td3.set("style", "font-size: small;")
ratings = ExperimentsOverview.getRating(step[0])
for rating in ratings:
if int(rating[2]) in devices:
td = etree.SubElement(tr, "td")
td.set("style", "font-size: small;text-align: left; vertical-align: top;")
p = etree.SubElement(td, "p")
p.set("style","font-style: bold;")
p.text = rating[0]
if details:
p2 = etree.SubElement(td, "p")
p2.text = rating[3]
# add sums
tr = etree.SubElement(tbody, "tr")
td = etree.SubElement(tr, "td")
td = etree.SubElement(tr, "td")
td = etree.SubElement(tr, "td")
sums = ExperimentsOverview.getSumRatings(case[0])
for sum in sums:
if int(sum[1]) in devices:
td = etree.SubElement(tr, "td")
td.text = str(sum[2])
h1 = etree.SubElement(body,"h1")
h1.text = "sol_arch"
table = etree.SubElement(body, "table")
table.set("border","1 px")
table.set("width", "1024px")
comments = ExperimentsOverview.getSolArch()
tr = etree.SubElement(table, "tr")
td = etree.SubElement(tr, "td")
td.text = "device\npackage"
td2 = etree.SubElement(tr, "td")
td2.text = "comment"
for comment in comments:
tr = etree.SubElement(table, "tr")
td = etree.SubElement(tr, "td")
td.text = comment[0]
br = etree.SubElement(td, "br")
br.tail = comment[1]
td2 = etree.SubElement(tr, "td")
td2.text = comment[2]
options = {
'page-size': 'Letter',
'margin-top': '0.75in',
'margin-right': '0.75in',
'margin-bottom': '0.75in',
'margin-left': '0.75in',
'encoding': "UTF-8",
'no-outline': None,
'orientation': 'Landscape'
}
file = open("doc/{}.html".format(file_name),'w')
tree.write(file, pretty_print=True, encoding="us-ascii", xml_declaration=None, method="html")
pdfkit.from_file("doc/{}.html".format(file_name),"doc/{}.pdf".format(file_name), options=options)
def __init__(self, data):
self._stm = StringIO.StringIO(data)
def download_search(info):
dltype = info['Submit']
delim = 'bracket'
com = r'\\' # single line comment start
com1 = '' # multiline comment start
com2 = '' # multiline comment end
filename = 'elliptic_curves.gp'
mydate = time.strftime("%d %B %Y")
if dltype == 'sage':
com = '#'
filename = 'elliptic_curves.sage'
if dltype == 'magma':
com = ''
com1 = '/*'
com2 = '*/'
delim = 'magma'
filename = 'elliptic_curves.m'
s = com1 + "\n"
s += com + ' Elliptic curves downloaded from the LMFDB downloaded on %s.\n'%(mydate)
s += com + ' Below is a list called data. Each entry has the form:\n'
s += com + ' [[field_poly],[Weierstrass Coefficients, constant first in increasing degree]]\n'
s += '\n' + com2
s += '\n'
if dltype == 'magma':
s += 'P<x> := PolynomialRing(Rationals()); \n'
s += 'data := ['
elif dltype == 'sage':
s += 'x = polygen(QQ) \n'
s += 'data = [ '
else:
s += 'data = [ '
s += '\\\n'
nf_dict = {}
res = db_ecnf().find(ast.literal_eval(info["query"]))
for f in res:
nf = str(f['field_label'])
# look up number field and see if we already have the min poly
if nf in nf_dict:
poly = nf_dict[nf]
else:
poly = str(WebNumberField(f['field_label']).poly())
nf_dict[nf] = poly
entry = str(f['ainvs'])
entry = entry.replace('u','')
entry = entry.replace('\'','')
s += '[[' + poly + '], ' + entry + '],\\\n'
s = s[:-3]
s += ']\n'
if delim == 'brace':
s = s.replace('[', '{')
s = s.replace(']', '}')
if delim == 'magma':
s = s.replace('[', '[*')
s = s.replace(']', '*]')
s += ';'
strIO = StringIO.StringIO()
strIO.write(s)
strIO.seek(0)
return send_file(strIO,
attachment_filename=filename,
as_attachment=True,
add_etags=False)
def to_json(obj):
"\n Converts 'obj' to an ASCII JSON string representation.\n "
stm = StringIO.StringIO('')
_to_json_object(stm, obj)
return stm.getvalue()
class SelectEventWindow(QtGui.QMainWindow):
# Give the window a closed signal. This is necessary for the faked
# multi-window application.
closed = QtCore.pyqtSignal()
# A signal that is emitted when the "Choose event" button has been clicked.
event_chosen = QtCore.pyqtSignal(Event)
def __init__(self, base_url):
QtGui.QMainWindow.__init__(self)
self.base_url = base_url
self.ui = ui_select_event_window.Ui_SelectEventWindow()
self.ui.setupUi(self)
center_Qt_window(self)
# Init event list and currently selected event.
self.events = []
self.currently_selected_event = None
self.current_selected_event_object = None
self.init_widgets()
self.connect_signals_and_slots()
self.update_plot()
def init_widgets(self):
"""
"""
# Set the timeframe to the last two week.
self.ui.starttime.setDateTime(
UTCtoQDateTime(UTCDateTime() - 86000 * 14))
self.ui.endtime.setDateTime(UTCtoQDateTime(UTCDateTime()))
self.ui.webView.setPage(GoogleMapsWebView())
map_file = os.path.abspath(os.path.join(os.path.dirname(
inspect.getfile(inspect.currentframe())), "resources",
"html_resources", "map.html"))
self.ui.webView.load(QtCore.QUrl.fromLocalFile(map_file))
self.ui.webView.page().mainFrame().addToJavaScriptWindowObject("pyObj",
self)
def closeEvent(self, event):
self.closed.emit()
event.accept()
@QtCore.pyqtSlot(str)
def set_lat_long_bounds(self, bounds):
"""
Set the latitude longitude bounds as a string, e.g.:
"((lat_ne, long_ne), (lat_sw, long_sw))"
Used as a callback in the WebView JavaScript Code.
"""
self.north_east, self.south_west = [map(float, _i.split(", ")) \
for _i in str(bounds)[2:-2].split("), (")]
self.ui.northeast_label.setText("%.3f, %.3f" % (self.north_east[0],
self.north_east[1]))
self.ui.southwest_label.setText("%.3f, %.3f" % (self.south_west[0],
self.south_west[1]))
@QtCore.pyqtSlot(str)
def event_selected(self, event_id):
"""
Called when a new event has been selected. The event_id should be
enough to identify it.
Used as a callback in the WebView JavaScript Code.
"""
# Reset all detail object as soon as a new event is selected. Also
# disable the "Choose event" button.
self.ui.choose_event_button.setEnabled(False)
self.ui.selected_event_p_phase_picks.setText("-")
self.ui.selected_event_s_phase_picks.setText("-")
self.ui.selected_event_warning.setText("")
self.current_selected_event_object = None
for event in self.events:
if event["resource_name"] == event_id:
self.currently_selected_event = event
break
# Handle an eventual error.
if self.currently_selected_event is None:
QtGui.QMessageBox.critical(self, "Error",
"Selected event not found on the Python side. Please " + \
"contact the developer or fix the code yourself...")
return
ev = self.currently_selected_event
self.ui.selected_event_id_label.setText(ev["resource_name"])
self.ui.selected_latitude_label.setText("%.4f" % ev["latitude"])
self.ui.selected_longitude_label.setText("%.4f" % ev["longitude"])
self.ui.selected_depth_label.setText("%.4f" % ev["depth"])
self.ui.selected_origin_time_label.setText(str(ev["datetime"]))
self.ui.selected_magnitude_label.setText("%.3f %s" % \
(ev["magnitude"], ev["magnitude_type"]))
# Last but not least enable the detail loading button.
self.ui.selected_event_load_details.setEnabled(True)
def connect_signals_and_slots(self):
self.ui.search_events_button.clicked.connect(self.search_for_events)
self.ui.selected_event_load_details.clicked.connect(\
self.load_event_object)
self.ui.choose_event_button.clicked.connect(self.choose_event)
self.ui.cancel_button.clicked.connect(self.close)
def choose_event(self):
if self.current_selected_event_object is None:
QtGui.QMessageBox.critical(self, "Error",
"The event object cannot be found... Please " + \
"contact the developer or fix the code yourself...")
return
self.event_chosen.emit(self.current_selected_event_object)
self.close()
def load_event_object(self):
"""
Loads the currently selected event from the Seishub database.
"""
if self.currently_selected_event is None:
QtGui.QMessageBox.critical(self, "Error",
"Selected event not found - something is wrong. Please " + \
"contact the developer or fix the code yourself...")
return
from obspy.seishub import Client
client = Client(base_url=self.base_url)
try:
resource = client.event.getResource( \
self.currently_selected_event["resource_name"])
except Exception, e:
error_type_str = e.__class__.__name__
msg_box = QtGui.QMessageBox()
msg_box.setIcon(QtGui.QMessageBox.Critical)
msg_box.setText("Retrieving event from the SeisHub server " + \
"failed!")
msg_box.setDetailedText("{err_type}({message})".format( \
err_type=error_type_str,
message=str(e)))
msg_box.exec_()
return
file_object = StringIO.StringIO(resource)
self.current_selected_event_object = \
readSeishubEventFile(file_object)[0]
# Get the P and S wave pick counts.
p_picks = len([_i for _i in self.current_selected_event_object.picks \
if _i.phase_hint == "P"])
s_picks = len([_i for _i in self.current_selected_event_object.picks \
if _i.phase_hint == "S"])
if p_picks == 0 and s_picks == 0:
self.ui.selected_event_warning.setText( \
"Warning: Event has no associated picks.")
return
# If all is fine, update the pick count and enable the user to choose
# the event.
self.ui.selected_event_p_phase_picks.setText(str(p_picks))
self.ui.selected_event_s_phase_picks.setText(str(s_picks))
self.ui.choose_event_button.setEnabled(True)
