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 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 act_getfile(self, cr, uid, ids, context=None): this = self.browse(cr, uid, ids)[0] #lang = this.lang if this.lang != NEW_LANG_KEY else False #mods = map(lambda m: m.name, this.modules) or ['all'] #mods.sort() data = self.make_data(cr, uid, ids, this, context) #exp = self.browse(cr, uid, ids)[0] buf = StringIO() buf = self.generate_file_export(cr, uid, ids, buf, data, context) out = base64.encodestring(buf.getvalue()) buf.close() this.name = "Master_payroll.csv" writer = {'state': 'get', 'file': out, 'name': this.name} if context and len(context['active_ids']) > 0: slips = self.pool.get('hr.payslip').browse(cr, uid, context['active_ids']) writer.update({'payslip_ids': [(6, 0, context['active_ids'])]}) self.write(cr, uid, ids, writer, context=context) return { 'type': 'ir.actions.act_window', 'res_model': 'hr.master.payroll', 'view_mode': 'form', 'view_type': 'form', 'res_id': this.id, 'views': [(False, 'form')], #'target': 'new', }
def generateMainpageHTML(self): fout = open('%s/index.html' % self.LogBookFolder, 'w') fout.write('<html>\n<body>\n') tableout = StringIO() tableout.write('<table border = \'1\'>\n') entriesRevOrder = [x for x in self.entries] entriesRevOrder.sort() entriesRevOrder.reverse() for datestr in entriesRevOrder: self.writeDateEntryHTML(tableout, datestr) for entry in self.entries[datestr]: self.writeSubEntryHTMLBegin(tableout, entry) for tag in entry.tags: if not tag in self.tags: self.tags[tag] = 0 self.tags[tag] = self.tags[tag] + 1 self.writeTagLinkHTML(tableout, tag) self.writeSubEntryHTMLEnd(tableout) tableout.write('</table>\n') tablestring = tableout.getvalue() tableout.close() self.writeTagCountsHTML(fout) fout.write(tablestring) fout.write('</body>\n</html>\n')
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 encFile(file_name, passphrase): a = StringIO() yield a KEYRING = './keyring.gpg' SECRET_KEYRING = './secring.gpg' GPGBINARY = 'gpg' gpg = gnupg.GPG(gnupghome='.', gpgbinary=GPGBINARY, keyring=KEYRING, secret_keyring=SECRET_KEYRING, options=[ '--throw-keyids', '--personal-digest-preferences=sha256', '--s2k-digest-algo=sha256' ]) gpg.encoding = 'latin-1' ciphertext = gpg.encrypt(a.getvalue(), recipients=None, symmetric='AES256', armor=False, always_trust=True, passphrase=passphrase) a.close() with open(file_name, 'wb') as f: f.write(ciphertext.data)
def dump(self, data, stream=None, **kw): if not stream: stream = StringIO() try: yaml.dump(data=data, stream=stream, Dumper=yaml.Dumper, **kw) return self._license_filter(stream.getvalue().strip()) finally: stream.close()
def dump(self, data, stream=None, **kw): if not stream: stream = StringIO() try: RYAML.dump(self, data, stream, **kw) return self._license_filter(stream.getvalue().strip()) finally: stream.close()
def _print(request,template,output_format,output_file_ext,content_type): metadata = get_metadata(request) output_file = tempfile.mkstemp(suffix=output_file_ext,prefix="{}_".format(template))[1] print_js_file = "{}.js".format(output_file) sso_cookie = request.COOKIES.get(settings.SSO_COOKIE_NAME,"") print_html = pathlib.Path(os.path.join(app_dir,"static","{}.html".format(template))).as_uri() metadata_str = json.dumps(metadata,indent=4) context = Context({ "output_format":output_format, "output_file":output_file, "sso_cookie":'1qzhg1by1hs5c4frudmftbq2we8v97j2', "sso_cookie_name":settings.SSO_COOKIE_NAME, "sso_cookie_domain":settings.SSO_COOKIE_DOMAIN, "print_html":print_html, "metadata" : metadata_str, "login_user":{"name":"rockyc","email":"*****@*****.**"}, "timeout":300, "log_level":logger.getEffectiveLevel(), "working_directory":working_directory, "keep_tmp_file": json.dumps(settings.KEEP_TMP_FILE) }) try: with open(print_js_file,'wb') as print_js: print_js.write(bytes(print_template.render(context),'UTF-8')) print_js.flush() print_process = subprocess.Popen(["phantomjs",print_js.name], stdout=subprocess.PIPE, stderr=subprocess.PIPE) log_stddout = threading.Thread(target="") error = StringIO() try: stdout_thread = threading.Thread(target=log_subprocess_stdout,args=(print_process.stdout,error)) stdout_thread.setDaemon(True) stdout_thread.start() stderr_thread = threading.Thread(target=log_subprocess_stderr,args=(print_process.stderr,error)) stderr_thread.setDaemon(True) stderr_thread.start() stdout_thread.join() stderr_thread.join() print_process.poll() while(print_process.returncode is None): print_process.poll() time.sleep(1) if print_process.returncode != 0: logger.error("Generate print document failed, \nreason={}".format(error.getvalue())) os.remove(output_file) return HttpResponse("<html><head/><body><pre>{}</pre></body>".format(error.getvalue()),status=500) if settings.KEEP_TMP_FILE: response = FileResponse(open(output_file, 'rb'),content_type=content_type) else: response = TempFileResponse(open(output_file, 'rb'),content_type=content_type) return response; finally: error.close() finally: if not settings.KEEP_TMP_FILE: os.remove(print_js_file)
def mat2cv(m): fig = pylab.figure(1) ax = pylab.matshow(m,fignum=1) buf = StringIO() fig.savefig(buf,format='png') buf.seek(0) pi = Image.open(buf) cv_im = cv.CreateImageHeader(pi.size, cv.IPL_DEPTH_8U, 3) cv.SetData(cv_im, pi.tostring(),pi.size[0]*3) buf.close() return cv_im
def disassemble(func): from StringIO import StringIO import sys, dis f = StringIO() tmp = sys.stdout sys.stdout = f dis.dis(func) sys.stdout = tmp result = f.getvalue() f.close() return result
def main(): make_option = optparse.make_option opt = optparse.OptionParser(option_list=[ make_option('-o', dest='output', help='write to FILE', metavar='FILE'), make_option('-d', dest='depends', help='write dependencies to FILE', metavar='FILE', default=None), make_option('-m', dest='manifest', help='read manifest from FILE', metavar='FILE'), make_option('-D', type='string', help='define VAR=DATA', metavar='VAR=DATA', action='callback', callback=add_var), ]) (options, args) = opt.parse_args() depends = StringIO() if options.depends: depends = file(options.depends, 'w') manifest = configparser.SafeConfigParser() manifest.optionxform = str # avoid lowercasing manifest.read(options.manifest) depends.write('%s: \\\n' % (options.output, )) image_path = os.path.abspath(options.output) osv = subprocess.Popen( 'cd ../..; scripts/run.py --vnc none -m 512 -c1 -i %s -u -s -e "--norandom --noinit /tools/cpiod.so" --forward tcp:10000::10000' % image_path, shell=True, stdout=subprocess.PIPE) upload(osv, manifest, depends) osv.wait() # Disable ZFS compression; it stops taking effect from this point on. osv = subprocess.Popen( 'cd ../..; scripts/run.py -m 512 -c1 -i %s -u -s -e "--norandom --noinit /zfs.so set compression=off osv"' % image_path, shell=True, stdout=subprocess.PIPE) osv.wait() depends.write('\n\n') depends.close()
def main(): make_option = optparse.make_option opt = optparse.OptionParser(option_list=[ make_option('-o', dest='output', help='write to FILE', metavar='FILE'), make_option('-d', dest='depends', help='write dependencies to FILE', metavar='FILE', default=None), make_option('-m', dest='manifest', help='read manifest from FILE', metavar='FILE'), make_option('-D', type='string', help='define VAR=DATA', metavar='VAR=DATA', action='callback', callback=add_var), make_option('-x', dest='emulation', help='use emulation instead of a hypervisor', metavar='FILE'), ]) (options, args) = opt.parse_args() depends = StringIO() if options.depends: depends = file(options.depends, 'w') manifest = read_manifest(options.manifest) depends.write('%s: \\\n' % (options.output,)) image_path = os.path.abspath(options.output) osv = None if options.emulation == 'y': print("Using emulation (no hypervisor support) for image creation") osv = subprocess.Popen('cd ../..; scripts/run.py --vnc none -m 512 -c1 -i %s -u -s -p none -e "--norandom --nomount --noinit /tools/mkfs.so; /tools/cpiod.so --prefix /zfs/zfs/; /zfs.so set compression=off osv" --forward tcp:10000::10000' % image_path, shell=True, stdout=subprocess.PIPE) else: print("Using hypervisor support for image creation") osv = subprocess.Popen('cd ../..; scripts/run.py --vnc none -m 512 -c1 -i %s -u -s -e "--norandom --nomount --noinit /tools/mkfs.so; /tools/cpiod.so --prefix /zfs/zfs/; /zfs.so set compression=off osv" --forward tcp:10000::10000' % image_path, shell=True, stdout=subprocess.PIPE) upload(osv, manifest, depends) osv.wait() depends.write('\n\n') depends.close()
def disassemble(func): from StringIO import StringIO import sys, dis f = StringIO() tmp = sys.stdout sys.stdout = f dis.dis(func) sys.stdout = tmp result = f.getvalue() f.close() return result
def execwo(v): codeOut = StringIO() codeErr = StringIO() sys.stdout = codeOut sys.stderr = codeErr exec(v) sys.stdout = sys.__stdout__ sys.stderr = sys.__stderr__ rv = (codeOut.getvalue(), codeErr.getvalue()) codeOut.close() codeErr.close() return rv
def create_from_file(self, permid, srcfilename): """ srcfilename must point to an image file processable by wx.Image """ try: sim = wx.Image(srcfilename).Scale(ICON_MAX_DIM, ICON_MAX_DIM) sim.SaveFile(dstfilename, wx.BITMAP_TYPE_JPEG) f = StringIO() sim.SaveStream(f, wx.BITMAP_TYPE_JPEG) self.peer_db.updatePeerIcon('image/jpeg', f.getvalue()) f.close() except: if DEBUG: print_exc() pass
def getURL(): try: import StringIO except ImportError: from io import StringIO c = pycurl.Curl() buf = StringIO() c.setopt(c.URL, 'https://api.twitch.tv/kraken/streams/{}/'.format(settings.channel.split('#')[1])) c.setopt(c.WRITEFUNCTION, buf.write) c.perform() ret = buf.getvalue() buf.close() return ret
def renderContent(self, xml, frameID, channelID = None): transform = self.stylesheetMap.get((frameID, channelID)) if transform == None: return xml else: try: xmlHandle = StringIO(xml) documentTree = etree.parse(xmlHandle) result = transform(documentTree) return str(result) finally: xmlHandle.close()
def main(): make_option = optparse.make_option opt = optparse.OptionParser(option_list=[ make_option('-o', dest='output', help='write to FILE', metavar='FILE'), make_option('-d', dest='depends', help='write dependencies to FILE', metavar='FILE', default=None), make_option('-m', dest='manifest', help='read manifest from FILE', metavar='FILE'), make_option('-D', type='string', help='define VAR=DATA', metavar='VAR=DATA', action='callback', callback=add_var), ]) (options, args) = opt.parse_args() depends = StringIO() if options.depends: depends = file(options.depends, 'w') manifest = configparser.SafeConfigParser() manifest.optionxform = str # avoid lowercasing manifest.read(options.manifest) depends.write('%s: \\\n' % (options.output,)) image_path = os.path.abspath(options.output) osv = subprocess.Popen('cd ../..; scripts/run.py --vnc none -m 512 -c1 -i %s -u -s -e "--norandom --noinit /tools/cpiod.so" --forward tcp:10000::10000' % image_path, shell=True, stdout=subprocess.PIPE) upload(osv, manifest, depends) osv.wait() # Disable ZFS compression; it stops taking effect from this point on. osv = subprocess.Popen('cd ../..; scripts/run.py -m 512 -c1 -i %s -u -s -e "--norandom --noinit /zfs.so set compression=off osv"' % image_path, shell=True, stdout=subprocess.PIPE) osv.wait() depends.write('\n\n') depends.close()
def main(): make_option = optparse.make_option opt = optparse.OptionParser( option_list=[ make_option("-o", dest="output", help="write to FILE", metavar="FILE"), make_option("-d", dest="depends", help="write dependencies to FILE", metavar="FILE", default=None), make_option("-m", dest="manifest", help="read manifest from FILE", metavar="FILE"), make_option( "-D", type="string", help="define VAR=DATA", metavar="VAR=DATA", action="callback", callback=add_var ), ] ) (options, args) = opt.parse_args() depends = StringIO() if options.depends: depends = file(options.depends, "w") manifest = configparser.SafeConfigParser() manifest.optionxform = str # avoid lowercasing manifest.read(options.manifest) depends.write("%s: \\\n" % (options.output,)) image_path = os.path.abspath(options.output) osv = subprocess.Popen( 'cd ../..; scripts/run.py --vnc none -m 512 -c1 -i %s -u -s -e "--norandom --noinit /tools/cpiod.so" --forward tcp:10000::10000' % image_path, shell=True, stdout=subprocess.PIPE, ) upload(osv, manifest, depends) osv.wait() # Disable ZFS compression; it stops taking effect from this point on. osv = subprocess.Popen( 'cd ../..; scripts/run.py -m 512 -c1 -i %s -u -s -e "--norandom --noinit /zfs.so set compression=off osv"' % image_path, shell=True, stdout=subprocess.PIPE, ) osv.wait() depends.write("\n\n") depends.close()
def LoadConfig(): Config.parser = ConfigParser() try: sconff = open(CONFIG_FILE, "r") except: Log.warn("cannot open config file") return sconf = StringIO() sconf.write("[sysconf]\n") sconf.write(sconff.read()) sconf.seek(0) Config.parser.readfp(sconf) sconff.close() sconf.close() return
def _get_barcode_img(cls, Withholding, withholding): from barras import CodigoBarra from cStringIO import StringIO as StringIO # create the helper: codigobarra = CodigoBarra() output = StringIO() bars = withholding.numero_autorizacion codigobarra.GenerarImagen(bars, output, basewidth=3, width=380, height=50, extension="PNG") image = buffer(output.getvalue()) output.close() return image
def LoadConfig(): Config.parser = ConfigParser() try: sconff = open(CONFIG_FILE, "r") except: Log.warn("cannot open config file") return sconf = StringIO() sconf.write("[sysconf]\n") sconf.write(sconff.read()) sconf.seek(0) Config.parser.readfp(sconf) sconff.close() sconf.close() return
def main(): make_option = optparse.make_option opt = optparse.OptionParser(option_list=[ make_option('-o', dest='output', help='write to FILE', metavar='FILE'), make_option('-d', dest='depends', help='write dependencies to FILE', metavar='FILE', default=None), make_option('-m', dest='manifest', help='read manifest from FILE', metavar='FILE'), make_option('-D', type='string', help='define VAR=DATA', metavar='VAR=DATA', action='callback', callback=add_var), ]) (options, args) = opt.parse_args() depends = StringIO() if options.depends: depends = file(options.depends, 'w') manifest = read_manifest(options.manifest) depends.write('%s: \\\n' % (options.output, )) image_path = os.path.abspath(options.output) upload_port = find_free_port() osv = subprocess.Popen( 'cd ../..; scripts/run.py --vnc none -m 512 -c1 -i "%s" -u -s -e "--norandom --nomount --noinit /tools/mkfs.so; /tools/cpiod.so --prefix /zfs/zfs/; /zfs.so set compression=off osv" --forward tcp:127.0.0.1:%s-:10000' % (image_path, upload_port), shell=True, stdout=subprocess.PIPE) upload(osv, manifest, depends, upload_port) ret = osv.wait() if ret != 0: sys.exit("Upload failed.") depends.write('\n\n') depends.close()
def pack(self, protocol_object): assert isinstance(protocol_object, self.msg_cls) _data = struct.pack('>I', self.msg_code) + protocol_object.SerializeToString() if self.compress: mstream = StringIO() f = gzip.GzipFile(mode='wb', compresslevel=6, fileobj=mstream) f.write(_data) f.close() _data = mstream.getvalue() mstream.close() if self.timestamp: insertData = chr(self.compress) + chr(self.timestamp) + struct.pack('>Q', int(time.time()*1000)) else: insertData = chr(self.compress) + chr(self.timestamp) compressIdx = (len(_data) + len(insertData))/3 _data = _data[:compressIdx] + insertData + _data[compressIdx:] return _data
class Export(object): ''' Base class for all Exporters. ''' def __init__(self): super(Export, self).__init__() # Export initialization self._render_set = set() # Used in rendering to prevent rendering # of the same node multiple times self._adapter_map = {} # Used as a registry of adapters to ensure # ensure that the same adapter is # returned for the same adaptee object def export(self, obj): '''Export of obj to a string.''' self._outf = StringIO() self._export(obj) return self._outf.getvalue() def exportFile(self, obj, file_name): '''Export of obj to a file.''' self._outf = open(file_name, "w") self._export(obj) self._outf.close() def _export(self, obj): self._outf.write(self._start()) self._render_node(obj) self._outf.write(self._end()) def _start(self): ''' Overide this to specify the begining of the graph representation. ''' return "" def _end(self): ''' Overide this to specify the end of the graph representation. ''' return ""
def readXML(f): start_of_xml = -1 end_of_xml = -1 xml_str = StringIO() while True: byte = f.read(1) if start_of_xml == -1 and byte == markers.OPEN_CHEVRON: start_of_xml = f.tell() if start_of_xml > -1: if byte == markers.NUL: break else: xml_str.write(byte) profile.add_xml_to_profile(xml_str.getvalue()) xml_str.close()
def post_reset(self, challenge_id): curl_post = pycurl.Curl() post_response = StringIO() curl_URL = 'http://' + os.environ['CTF_URL'] + '/api/reset_question' #curl_post.setopt(curl_post.URL, 'http://ai.defcon.ichunqiu.com/api/reset_question) curl_post.setopt(curl_post.URL, curl_URL) post_data = 'ChallengeID=' + challenge_id curl_post.setopt(curl_post.POST, 1) curl_post.setopt(pycurl.USERPWD, 'user01' + ':' + '938524') curl_post.setopt(curl_post.POSTFIELDS, post_data) curl_post.setopt(curl_post.CONNECTTIMEOUT, 10) curl_post.setopt(curl_post.TIMEOUT, 20) curl_post.setopt(curl_post.WRITEFUNCTION, post_response.write) curl_post.perform() reset_status = json.loads(post_response.getvalue()).get('status') print 'status ' + str(reset_status) post_response.close() curl_post.close() return reset_status
def generate_file(self): #wzd_values = self.read(cr,uid,ids,context=context)[0] path = '/tmp/file_%s.csv' % (datetime.today()) export_objs = self.env['economical.activities'].search([]) fp = StringIO() with open(path, 'w') as csvfile: fieldnames = ['code', 'name'] writer = csv.DictWriter(csvfile, fieldnames=fieldnames) writer.writeheader() for line in export_objs: print line writer.writerow({ 'code': str(line.code), 'name': str(line.name.encode('utf-8').strip()) }) fp.close() csvfile.close() arch = open(path, 'r').read() data = base64.encodestring(arch) attach_vals = { 'name': 'File%s.csv' % (datetime.today().strftime("%d-%m-%Y")), 'datas': data, 'datas_fname': 'File#_%s.csv' % (datetime.today().strftime("%d-%m-%Y")), } doc_id = self.env['ir.attachment'].create(attach_vals) return { 'type': "ir.actions.act_url", 'url': "web/content/?model=ir.attachment&id=" + str(doc_id.id) + "&filename_field=datas_fname&field=datas&download=true&filename=" + str(doc_id.name), 'target': "self", }
def build_archive(logs): fd = tempfile.SpooledTemporaryFile() tar = tarfile.open(mode='w:gz', fileobj=fd) bufs = [] for logdata in logs: tinf = tarfile.TarInfo(logdata['filename']) tinf.mtime = logdata['stat'].st_mtime tinf.mode = logdata['stat'].st_mode buf = StringIO() buf.write(logdata['contents']) buf.seek(0) bufs.append(buf) tinf.size = len(buf.buf) tar.addfile(tinf, fileobj=buf) tar.close() for buf in bufs: buf.close() fd.seek(0) s = fd.read() fd.close() return s
def post_answer(self, flag): curl_post = pycurl.Curl() post_response = StringIO() # c.setopt(pycurl.SSL_VERIFYHOST, False) # c.setopt(pycurl.SSL_VERIFYPEER, False) curl_URL = 'http://' + os.environ['CTF_URL'] + '/api/sub_answer' #curl_post.setopt(curl_post.URL, 'http://ai.defcon.ichunqiu.com/api/sub_answer') curl_post.setopt(curl_post.URL, curl_URL) post_data = 'answer=' + flag curl_post.setopt(curl_post.POST, 1) curl_post.setopt(pycurl.USERPWD, 'user01' + ':' + '938524') curl_post.setopt(curl_post.POSTFIELDS, post_data) curl_post.setopt(curl_post.CONNECTTIMEOUT, 10) curl_post.setopt(curl_post.TIMEOUT, 20) curl_post.setopt(curl_post.WRITEFUNCTION, post_response.write) curl_post.perform() flag_status = json.loads(post_response.getvalue()).get('status') print 'status ' + str(flag_status) post_response.close() curl_post.close() return flag_status
def assignStylesheet(self, xslFilename, frameID, channelID=None, **kwargs): # first, load the stylesheet as a Jinja template xslHandle = None try: xslTemplateObject = self.j2TemplateMgr.getTemplate(xslFilename) # resolve the Jinja tags in the template, place result in a file-like string object xslHandle = StringIO(xslTemplateObject.render()) # now use the resolved XSL (which should have no more Jinja tags) # as a valid & well-formed XSL stylesheet. xslTree = etree.parse(xslHandle) xslTransform = etree.XSLT(xslTree) self.stylesheetMap[(frameID, channelID)] = xslTransform except jinja2.TemplateError as err: pass #TODO: redirect to error page finally: if xslHandle is not None: xslHandle.close()
def build_archive(logs): fd = tempfile.SpooledTemporaryFile() tar = tarfile.open(mode='w:gz', fileobj=fd) bufs = [] for logdata in logs: tinf = tarfile.TarInfo(logdata['filename']) tinf.mtime = logdata['stat'].st_mtime tinf.mode = logdata['stat'].st_mode buf = StringIO() buf.write(logdata['contents']) buf.seek(0) bufs.append(buf) tinf.size = len(buf.buf) tar.addfile(tinf, fileobj=buf) tar.close() for buf in bufs: buf.close() fd.seek(0) s = fd.read() fd.close() return s
def decFile(file_name, passphrase): KEYRING = './keyring.gpg' SECRET_KEYRING = './secring.gpg' GPGBINARY = 'gpg' gpg = gnupg.GPG(gnupghome='.', gpgbinary=GPGBINARY, keyring=KEYRING, secret_keyring=SECRET_KEYRING, options=[ '--throw-keyids', '--personal-digest-preferences=sha256', '--s2k-digest-algo=sha256' ]) gpg.encoding = 'latin-1' with open(file_name, 'rb') as f: ciphertext = f.read() plaintext = gpg.decrypt(ciphertext, passphrase=passphrase, always_trust=True) a = StringIO(plaintext) a.seek(0) yield a a.close()
class SFTPStorageFile(File): def __init__(self, name, storage, mode): self._name = name self._storage = storage self._mode = mode self._is_dirty = False self.file = StringIO() self._is_read = False @property def size(self): if not hasattr(self, '_size'): self._size = self._storage.size(self._name) return self._size def read(self, num_bytes=None): if not self._is_read: self._storage._start_connection() self.file = self._storage._read(self._name) self._storage._end_connection() self._is_read = True return self.file.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 self._is_read = True def close(self): if self._is_dirty: self._storage._start_connection() self._storage._put_file(self._name, self.file.getvalue()) self._storage._end_connection() self.file.close()
class SFTPStorageFile(File): def __init__(self, name, storage, mode): self._name = name self._storage = storage self._mode = mode self._is_dirty = False self.file = StringIO() self._is_read = False @property def size(self): if not hasattr(self, '_size'): self._size = self._storage.size(self._name) return self._size def read(self, num_bytes=None): if not self._is_read: self._storage._start_connection() self.file = self._storage._read(self._name) self._storage._end_connection() self._is_read = True return self.file.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 self._is_read = True def close(self): if self._is_dirty: self._storage._start_connection() self._storage._put_file(self._name, self.file.getvalue()) self._storage._end_connection() self.file.close()
return Image.open(strio) def getScreenByPIL(self): import ImageGrab img = ImageGrab.grab() return img def getScreenByWx(self): import wx wx.App() # Need to create an App instance before doing anything screen = wx.ScreenDC() size = screen.GetSize() bmp = wx.EmptyBitmap(size[0], size[1]) mem = wx.MemoryDC(bmp) mem.Blit(0, 0, size[0], size[1], screen, 0, 0) del mem # Release bitmap #bmp.SaveFile('screenshot.png', wx.BITMAP_TYPE_PNG) myWxImage = wx.ImageFromBitmap( myBitmap ) PilImage = Image.new( 'RGB', (myWxImage.GetWidth(), myWxImage.GetHeight()) ) PilImage.fromstring( myWxImage.GetData() ) return PilImage if __name__ == '__main__': from cStringIO import StringIO s = screengrab() screen = s.screen() out = StringIO() screen.save(out, format="PNG") out.close() screen.show()
class formatController: '''A class to convert a Leo outline to rst/Sphinx markup. The outline is presumed to contain computer source code.''' #@+others #@+node:ekr.20100811091636.5922: *3* Birth & init #@+node:ekr.20100811091636.5923: *4* ctor (rstClass) def __init__ (self,c,p,defaultOptionsDict): self.c = c self.p = p.copy() self.defaultOptionsDict = defaultOptionsDict #@+<< init ivars >> #@+node:ekr.20100811091636.5924: *5* << init ivars >> # The options dictionary. self.optionsDict = {} self.vnodeOptionDict = {} # Formatting... self.code_block_string = '' self.node_counter = 0 self.topLevel = 0 self.topNode = None # For writing. self.atAutoWrite = False # True, special cases for writeAtAutoFile. self.atAutoWriteUnderlines = '' # Forced underlines for writeAtAutoFile. self.leoDirectivesList = g.globalDirectiveList self.encoding = 'utf-8' self.ext = None # The file extension. self.outputFileName = None # The name of the file being written. self.outputFile = None # The open file being written. self.path = '' # The path from any @path directive. self.source = None # The written source as a string. self.trialWrite = False # True if doing a trialWrite. #@-<< init ivars >> self.initOptionsFromSettings() # Still needed. self.initSingleNodeOptions() #@+node:ekr.20100811091636.5928: *4* initSingleNodeOptions def initSingleNodeOptions (self): self.singleNodeOptions = [ 'ignore_this_headline', 'ignore_this_node', 'ignore_this_tree', 'preformat_this_node', 'show_this_headline', ] #@+node:ekr.20100811091636.5931: *3* Options #@+node:ekr.20100811091636.5934: *4* get/SetOption def getOption (self,name): return self.optionsDict.get(self.munge(name)) def setOption (self,name,val,tag): self.optionsDict [self.munge(name)] = val #@+node:ekr.20100811091636.5929: *4* munge def munge (self,name): '''Convert an option name to the equivalent ivar name.''' return name.lower().replace('-','').replace('_','') #@+node:ekr.20100811091636.5944: *4* scanAllOptions & helpers # Once an option is seen, no other related options in ancestor nodes have any effect. def scanAllOptions(self,p): '''Scan position p and p's ancestors looking for options, setting corresponding ivars. ''' self.initOptionsFromSettings() # Must be done on every node. self.preprocessNode(p) self.handleSingleNodeOptions(p) seen = self.singleNodeOptions[:] # Suppress inheritance of single-node options. for p in p.self_and_parents(): d = self.vnodeOptionDict.get(p.v,{}) for key in d.keys(): if not key in seen: seen.append(key) val = d.get(key) self.setOption(key,val,tag=p.h) #@+node:ekr.20100811091636.5945: *5* initOptionsFromSettings def initOptionsFromSettings (self): d = self.defaultOptionsDict for key in sorted(d): self.setOption(key,d.get(key),'initOptionsFromSettings') #@+node:ekr.20100811091636.5946: *5* handleSingleNodeOptions def handleSingleNodeOptions (self,p): '''Init the settings of single-node options from the vnodeOptionsDict. All such options default to False.''' d = self.vnodeOptionDict.get(p.v, {} ) for ivar in self.singleNodeOptions: val = d.get(ivar,False) #g.trace('%24s %8s %s' % (ivar,val,p.h)) self.setOption(ivar,val,p.h) #@+node:ekr.20100811091636.5937: *5* preprocessNode def preprocessNode (self,p): d = self.vnodeOptionDict.get(p.v) if d is None: d = self.scanNodeForOptions(p) self.vnodeOptionDict [p.v] = d #@+node:ekr.20100811091636.5941: *5* scanNodeForOptions & helpers def scanNodeForOptions (self,p): '''Return a dictionary containing all the option-name:value entries in p. Such entries may arise from @rst-option or @rst-options in the headline, or from @ @rst-options doc parts.''' d = self.scanHeadlineForOptions(p) d2 = self.scanForOptionDocParts(p,p.b) d.update(d2) # Body options over-ride headline options. if d: g.trace(p.h,d) return d #@+node:ekr.20100811091636.5938: *6* parseOptionLine def parseOptionLine (self,s): '''Parse a line containing name=val and return (name,value) or None. If no value is found, default to True.''' s = s.strip() if s.endswith(','): s = s[:-1] # Get name. Names may contain '-' and '_'. i = g.skip_id(s,0,chars='-_') name = s [:i] if not name: return None j = g.skip_ws(s,i) if g.match(s,j,'='): val = s [j+1:].strip() # g.trace(val) return name,val else: # g.trace('*True') return name,'True' #@+node:ekr.20100811091636.5939: *6* scanForOptionDocParts def scanForOptionDocParts (self,p,s): '''Return a dictionary containing all options from @rst-options doc parts in p. Multiple @rst-options doc parts are allowed: this code aggregates all options. ''' d = {} ; n = 0 ; lines = g.splitLines(s) while n < len(lines): line = lines[n] ; n += 1 if line.startswith('@'): i = g.skip_ws(line,1) for kind in ('@rst-options','@rst-option'): if g.match_word(line,i,kind): # Allow options on the same line. line = line[i+len(kind):] d.update(self.scanOption(p,line)) # Add options until the end of the doc part. while n < len(lines): line = lines[n] ; n += 1 ; found = False for stop in ('@c','@code', '@'): if g.match_word(line,0,stop): found = True ; break if found: break else: d.update(self.scanOption(p,line)) break return d #@+node:ekr.20100811091636.5940: *6* scanHeadlineForOptions def scanHeadlineForOptions (self,p): '''Return a dictionary containing the options implied by p's headline.''' h = p.h.strip() if p == self.topNode: return {} # Don't mess with the root node. if g.match_word(h,0,self.getOption('@rst-options')): return self.scanOptions(p,p.b) else: # Careful: can't use g.match_word because options may have '-' chars. # i = g.skip_id(h,0,chars='@-') # word = h[0:i] for option,ivar,val in ( ('@rst-no-head','ignore_this_headline',True), ('@rst-head' ,'show_this_headline',True), ('@rst-no-headlines','show_headlines',False), ('@rst-ignore','ignore_this_tree',True), ('@rst-ignore-node','ignore_this_node',True), ('@rst-ignore-tree','ignore_this_tree',True), # ('@rst-preformat','preformat_this_node',True), ): name = self.getOption(option) if name: d = { name: val } return d return {} #@+node:ekr.20100811091636.5942: *6* scanOption def scanOption (self,p,s): '''Return { name:val } if s is a line of the form name=val. Otherwise return {}''' if not s.strip() or s.strip().startswith('..'): return {} data = self.parseOptionLine(s) if data: name,val = data if name in list(self.defaultOptionsDict.keys()): if val.lower() == 'true': val = True elif val.lower() == 'false': val = False # g.trace('%24s %8s %s' % (self.munge(name),val,p.h)) return { self.munge(name): val } else: g.es_print('ignoring unknown option: %s' % (name),color='red') return {} else: g.trace(repr(s)) s2 = 'bad rst3 option in %s: %s' % (p.h,s) g.es_print(s2,color='red') return {} #@+node:ekr.20100811091636.5943: *6* scanOptions def scanOptions (self,p,s): '''Return a dictionary containing all the options in s.''' d = {} for line in g.splitLines(s): d2 = self.scanOption(p,line) if d2: d.update(d2) return d #@+node:ekr.20100811091636.6000: *3* Writing #@+node:ekr.20100811091636.5984: *4* encode def encode (self,s): # g.trace(self.encoding) return g.toEncodedString(s,encoding=self.encoding,reportErrors=True) #@+node:ekr.20100811091636.5930: *4* run def run (self,event=None): fn = self.defaultOptionsDict.get('output-file-name','format-code.rst.txt') self.outputFileName = g.os_path_finalize_join(g.app.loadDir,fn) self.outputFile = StringIO() # Not a binary file. print('\n\n\n==========') self.writeTree(self.p.copy()) s = self.outputFile.getvalue() self.outputFile = open(self.outputFileName,'w') self.outputFile.write(s) self.outputFile.close() g.es('rst-format: wrote',self.outputFileName) #@+node:ekr.20100811091636.5987: *4* underline def underline (self,s,p): '''Return the underlining string to be used at the given level for string s.''' trace = False and not g.unitTesting # The user is responsible for top-level overlining. u = self.getOption('underline_characters') # '''#=+*^~"'`-:><_''' level = max(0,p.level()-self.topLevel) level = min(level+1,len(u)-1) # Reserve the first character for explicit titles. ch = u [level] if trace: g.trace(self.topLevel,p.level(),level,repr(ch),p.h) n = max(4,len(g.toEncodedString(s,encoding=self.encoding,reportErrors=False))) return '%s\n%s\n\n' % (p.h.strip(),ch*n) #@+node:ekr.20100811091636.5975: *4* write def write (self,s): # g.trace('%20s %20s %20s %s' % (self.p.h[:20],repr(s)[:20],repr(s)[-20:],g.callers(2))) # g.trace('%20s %40s %s' % (self.p.h[:20],repr(s)[:40],g.callers(2))) if g.isPython3: if g.is_binary_file(self.outputFile): s = self.encode(s) else: s = self.encode(s) self.outputFile.write(s) #@+node:ekr.20100811091636.5976: *4* writeBody & helpers def writeBody (self,p): trace = False self.p = p.copy() # for traces. if not p.b.strip(): return # No need to write any more newlines. showDocsAsParagraphs = self.getOption('show_doc_parts_as_paragraphs') lines = g.splitLines(p.b) parts = self.split_parts(lines,showDocsAsParagraphs) result = [] for kind,lines in parts: if trace: g.trace(kind,len(lines),p.h) if kind == '@rst-option': # Also handles '@rst-options' pass # The prepass has already handled the options. elif kind == '@rst-markup': lines.extend('\n') result.extend(lines) elif kind == '@doc': if showDocsAsParagraphs: result.extend(lines) result.append('\n') else: result.extend(self.write_code_block(lines)) elif kind == 'code': result.extend(self.write_code_block(lines)) else: g.trace('Can not happen',kind) # Write the lines with exactly two trailing newlines. s = ''.join(result).rstrip() + '\n\n' self.write(s) #@+node:ekr.20100811091636.6003: *5* split_parts def split_parts (self,lines,showDocsAsParagraphs): '''Split a list of body lines into a list of tuples (kind,lines).''' kind,parts,part_lines = 'code',[],[] for s in lines: if g.match_word(s,0,'@ @rst-markup'): if part_lines: parts.append((kind,part_lines[:]),) kind = '@rst-markup' n = len('@ @rst-markup') after = s[n:].strip() part_lines = g.choose(after,[after],[]) elif s.startswith('@ @rst-option'): if part_lines: parts.append((kind,part_lines[:]),) kind,part_lines = '@rst-option',[s] # part_lines will be ignored. elif s.startswith('@ ') or s.startswith('@\n') or s.startswith('@doc'): if showDocsAsParagraphs: if part_lines: parts.append((kind,part_lines[:]),) kind = '@doc' # Put only what follows @ or @doc n = g.choose(s.startswith('@doc'),4,1) after = s[n:].lstrip() part_lines = g.choose(after,[after],[]) else: part_lines.append(s) # still in code mode. elif g.match_word(s,0,'@c') and kind != 'code': if kind == '@doc' and not showDocsAsParagraphs: part_lines.append(s) # Show the @c as code. parts.append((kind,part_lines[:]),) kind,part_lines = 'code',[] else: part_lines.append(s) if part_lines: parts.append((kind,part_lines[:]),) return parts #@+node:ekr.20100811091636.6004: *5* write_code_block def write_code_block (self,lines): result = ['::\n\n'] # ['[**code block**]\n\n'] if self.getOption('number-code-lines'): i = 1 for s in lines: result.append(' %d: %s' % (i,s)) i += 1 else: result.extend([' %s' % (z) for z in lines]) s = ''.join(result).rstrip()+'\n\n' return g.splitLines(s) #@+node:ekr.20100811091636.5977: *4* writeHeadline & helper def writeHeadline (self,p): '''Generate an rST section if options permit it. Remove headline commands from the headline first, and never generate an rST section for @rst-option and @rst-options.''' docOnly = self.getOption('doc_only_mode') ignore = self.getOption('ignore_this_headline') showHeadlines = self.getOption('show_headlines') showThisHeadline = self.getOption('show_this_headline') showOrganizers = self.getOption('show_organizer_nodes') if ( p == self.topNode or ignore or docOnly or # handleDocOnlyMode handles this. not showHeadlines and not showThisHeadline or # docOnly and not showOrganizers and not thisHeadline or not p.h.strip() and not showOrganizers or not p.b.strip() and not showOrganizers ): return self.writeHeadlineHelper(p) #@+node:ekr.20100811091636.5978: *5* writeHeadlineHelper def writeHeadlineHelper (self,p): h = p.h.strip() # Remove any headline command before writing the headline. i = g.skip_ws(h,0) i = g.skip_id(h,0,chars='@-') word = h [:i].strip() if word: # Never generate a section for @rst-option or @rst-options or @rst-no-head. if word in ('@rst-option','@rst-options','@rst-no-head','@rst-no-leadlines'): return # Remove all other headline commands from the headline. # self.getOption('ignore_node_prefix'), # self.getOption('ignore_tree_prefix'), # self.getOption('show_headline_prefix'), ### for prefix in self.headlineCommands: for prefix in ('@rst-ignore-node','@rst-ignore-tree','@rst-ignore'): if word == prefix: h = h [len(word):].strip() break # New in Leo 4.4.4. # if word.startswith('@'): # if self.getOption('strip_at_file_prefixes'): # for s in ('@auto','@file','@nosent','@thin',): # if g.match_word(word,0,s): # h = h [len(s):].strip() if not h.strip(): return if self.getOption('show_sections'): self.write(self.underline(h,p)) else: self.write('\n**%s**\n\n' % h.replace('*','')) #@+node:ekr.20100811091636.5979: *4* writeNode def writeNode (self,p): '''Format a node according to the options presently in effect. Side effect: advance p''' h = p.h.strip() self.scanAllOptions(p) if self.getOption('ignore_this_tree'): p.moveToNodeAfterTree() elif self.getOption('ignore_this_node'): p.moveToThreadNext() elif g.match_word(h,0,'@rst-options') and not self.getOption('show_options_nodes'): p.moveToThreadNext() else: self.writeHeadline(p) self.writeBody(p) p.moveToThreadNext() #@+node:ekr.20100811091636.5981: *4* writeTree def writeTree(self,p): '''Write p's tree to self.outputFile.''' self.scanAllOptions(p) # So we can get the next option. if self.getOption('generate_rst_header_comment'): self.write('.. rst3: filename: %s\n\n' % self.outputFileName) # We can't use an iterator because we may skip parts of the tree. p = p.copy() # Only one copy is needed for traversal. self.topNode = p.copy() # Indicate the top of this tree. after = p.nodeAfterTree() while p and p != after: self.writeNode(p) # Side effect: advances p.
def get_csv(self,data): print "INICIO PROCESO WIZARD CSV" context = dict(self._context or {}) active_id = context.get('active_id', False) print "self>",self print "context>",context print "active_id>",active_id print "data>",data context = dict(self._context or {}) active_ids = data.get('active_ids', False) lines_total = [] productsx_ids = self.env['product.product'].search([('active', '=', True)]) for p in productsx_ids: print "p.name>>",p.name if p.attribute_line_ids: for a in p.attribute_line_ids: print "a.display_name>>",a.display_name if p.attribute_value_ids: for b in p.attribute_value_ids: print "b.display_name>>",b.name if self.report_option == '1': print "+++++++++++1111+++++++++++++" products_ids = self.env['product.product'].search([('active', '=', True)]) for p in products_ids: qty_sale = 0 print "p.name>>",p.name invoice_ids = self.env['account.invoice'].search([('date','>=', self.date_init), ('date','<=', self.date_end), ('type','=', 'in_invoice')]) print "+++++++++++11AA11+++++++++++++" for invoice in invoice_ids: print "invoice.name>>",invoice.id for line in invoice.invoice_line_ids: if line.product_id.id == p.id: print "line.product_id>>",line.product_id.id print "line.quantity>>",line.quantity qty_sale += line.quantity print "qty_sale>>",qty_sale if qty_sale != 0: name_aux = p.name print "p.name>>",p.name if p.attribute_line_ids: for a in p.attribute_line_ids: print "a.display_name>>",a.display_name name_aux = name_aux +"-"+a.display_name if p.attribute_value_ids: for b in p.attribute_value_ids: print "b.display_name>>",b.name name_aux = name_aux +"-"+b.name vals = { 'product_id':p.id, 'name':name_aux, 'category':p.categ_id.name or "", 'uom':p.product_tmpl_id.uom_id.name or "", 'qty_sale':qty_sale, } print "vals>>",vals lines_total.append(vals) elif qty_sale == 0 and self.products_without_rotation_view: name_aux = p.name print "p.name>>",p.name if p.attribute_line_ids: for a in p.attribute_line_ids: print "a.display_name>>",a.display_name name_aux = name_aux +"-"+a.display_name if p.attribute_value_ids: for b in p.attribute_value_ids: print "b.display_name>>",b.name name_aux = name_aux +"-"+b.name vals = { 'product_id':p.id, 'name':name_aux, 'category':p.categ_id.name, 'uom':p.product_tmpl_id.uom_id.name, 'qty_sale':0.0, } print "vals>>",vals lines_total.append(vals) print "+++++++++++22AA22+++++++++++++" print "+++++++++++22222+++++++++++++" print "Lines_total>>",lines_total for numPasada in range(len(lines_total)-1,0,-1): for i in range(numPasada): if lines_total[i]['qty_sale']<lines_total[i+1]['qty_sale']: temp = lines_total[i] lines_total[i] = lines_total[i+1] lines_total[i+1] = temp print "lines_total>>",lines_total path = '/tmp/file_%s.csv'% (datetime.today().strftime("%d-%m-%Y")) fp = StringIO() with open(path, 'w') as csvfile: csvfile.write("Reporte de; Rotacion de;Productos;\n") csvfile.write("Fecha Inicio:;{1};Fecha Fin;{3} \n".format("",self.date_init,"", self.date_init)) csvfile.write("Id Producto;Producto;Categoria; UM; Cantidad Comprada \n") for lin in lines_total: csvfile.write("{0};{1};{2};{3};{4} \n".format(lin['product_id'], lin['name'], lin['category'], lin['uom'], lin['qty_sale'])) fp.close() csvfile.close() arch = open(path, 'r').read() data = base64.encodestring(arch) attach_vals = { 'name':'Reporte de Rotacion de Productos %s.csv' % (datetime.today().strftime("%d-%m-%Y")), 'datas':data, 'datas_fname':'File#_%s.csv' % (datetime.today().strftime("%d-%m-%Y")), } doc_id = self.env['ir.attachment'].create(attach_vals) return { 'type' : "ir.actions.act_url", 'url': "web/content/?model=ir.attachment&id="+str(doc_id.id)+"&filename_field=datas_fname&field=datas&download=true&filename="+str(doc_id.name), 'target': "self", } if self.report_option == '2': print "+++++++++++1111+++++++++++++" products_ids = self.env['product.product'].search([('active', '=', True)]) for p in products_ids: qty_sale = 0 print "p.name>>",p.name invoice_ids = self.env['account.invoice'].search([('date','>=', self.date_init), ('date','<=', self.date_end), ('type','=', 'out_invoice')]) print "+++++++++++11AA11+++++++++++++" for invoice in invoice_ids: print "invoice.name>>",invoice.id for line in invoice.invoice_line_ids: if line.product_id.id == p.id: print "line.product_id>>",line.product_id.id print "line.quantity>>",line.quantity qty_sale += line.quantity print "qty_sale>>",qty_sale if qty_sale != 0: name_aux = p.name print "p.name>>",p.name if p.attribute_line_ids: for a in p.attribute_line_ids: print "a.display_name>>",a.display_name name_aux = name_aux +"-"+a.display_name if p.attribute_value_ids: for b in p.attribute_value_ids: print "b.display_name>>",b.name name_aux = name_aux +"-"+b.name vals = { 'product_id':p.id, 'name':name_aux, 'category':p.categ_id.name, 'uom':p.product_tmpl_id.uom_id.name, 'qty_sale':qty_sale, } print "vals>>",vals lines_total.append(vals) if qty_sale == 0 and self.products_without_rotation_view: name_aux = p.name print "p.name>>",p.name if p.attribute_line_ids: for a in p.attribute_line_ids: print "a.display_name>>",a.display_name name_aux = name_aux +"-"+a.display_name if p.attribute_value_ids: for b in p.attribute_value_ids: print "b.display_name>>",b.name name_aux = name_aux +"-"+b.name vals = { 'product_id':p.id, 'name':name_aux, 'category':p.categ_id.name, 'uom':p.product_tmpl_id.uom_id.name, 'qty_sale':0.0, } print "vals>>",vals lines_total.append(vals) print "+++++++++++22AA22+++++++++++++" print "+++++++++++22222+++++++++++++" print "Lines_total>>",lines_total for numPasada in range(len(lines_total)-1,0,-1): for i in range(numPasada): if lines_total[i]['qty_sale']<lines_total[i+1]['qty_sale']: temp = lines_total[i] lines_total[i] = lines_total[i+1] lines_total[i+1] = temp print "lines_total>>",lines_total path = '/tmp/file_%s.csv'% (datetime.today().strftime("%d-%m-%Y")) fp = StringIO() with open(path, 'w') as csvfile: csvfile.write("Reporte de; Rotacion de;Productos;\n") csvfile.write("Fecha Inicio:;{1};Fecha Fin;{3} \n".format("",self.date_init,"", self.date_init)) csvfile.write("Id Producto;Producto;Categoria; UM; Cantidad Vendida \n") for lin in lines_total: csvfile.write("{0};{1};{2};{3};{4} \n".format(lin['product_id'], lin['name'], lin['category'], lin['uom'], lin['qty_sale'])) fp.close() csvfile.close() arch = open(path, 'r').read() data = base64.encodestring(arch) attach_vals = { 'name':'Reporte de Rotacion de Productos %s.csv' % (datetime.today().strftime("%d-%m-%Y")), 'datas':data, 'datas_fname':'File#_%s.csv' % (datetime.today().strftime("%d-%m-%Y")), } doc_id = self.env['ir.attachment'].create(attach_vals) return { 'type' : "ir.actions.act_url", 'url': "web/content/?model=ir.attachment&id="+str(doc_id.id)+"&filename_field=datas_fname&field=datas&download=true&filename="+str(doc_id.name), 'target': "self", } return True
def mainCGI(): """ Main driver for running PDB2PQR from a web page """ print "Content-type: text/html\n" import cgi import cgitb cgitb.enable() form = cgi.FieldStorage() ff = form["FF"].value input = 0 apbs_input = form.has_key("INPUT") typemap = form.has_key("TYPEMAP") neutraln = form.has_key("NEUTRALN") neutralc = form.has_key("NEUTRALC") if HAVE_PDB2PQR_OPAL=="1": have_opal = True # Opal-specific import statments from AppService_client import AppServiceLocator, getAppMetadataRequest, launchJobRequest, launchJobBlockingRequest, getOutputAsBase64ByNameRequest from AppService_types import ns0 from ZSI.TC import String else: have_opal = False if have_opal: options = {} options["ff"] = ff fffile = None namesfile = None else: options = {"extensions":{}} if form.has_key("DEBUMP"): options["debump"] = 1 else: options["debump"] = 0 if form.has_key("OPT"): options["opt"] = 1 else: options["opt"] = 0 if form.has_key("PROPKA"): try: ph = float(form["PH"].value) if ph < 0.0 or ph > 14.0: raise ValueError options["ph"] = ph except ValueError: text = "The entered pH of %.2f is invalid! " % form["PH"].value text += "Please choose a pH between 0.0 and 14.0." #print "Content-type: text/html\n" print text sys.exit(2) if form.has_key("PDBID"): pdbfile = getPDBFile(form["PDBID"].value) pdbfilename = form["PDBID"].value elif form.has_key("PDB"): pdbfile = StringIO(form["PDB"].value) pdbfilename = form["PDB"].filename pdbfilename = re.split(r'[/\\]',pdbfilename)[-1] if form.has_key("INPUT"): input = 1 options["apbs"] = 1 if form.has_key("USERFF"): if have_opal: ffname = form["USERFF"].filename ffname = re.split(r'[/\\]',ffname)[-1] if ffname[-4:] == ".DAT": ffname = ffname[:-4] fffile = StringIO(form["USERFF"].value) namesfile = StringIO(form["USERNAMES"].value) options["ff"] = ffname options["userff"] = fffile options["usernames"] = namesfile else: userff = StringIO(form["USERFF"].value) usernames = StringIO(form["USERNAMES"].value) options["ff"] = "user-defined" options["userff"] = userff options["usernames"] = usernames if form.has_key("FFOUT"): if form["FFOUT"].value != "internal": options["ffout"] = form["FFOUT"].value if form.has_key("CHAIN"): options["chain"] = 1 if form.has_key("WHITESPACE"): options["whitespace"] = 1 if form.has_key("TYPEMAP"): options["typemap"] = 1 if form.has_key("NEUTRALN"): options["neutraln"] = 1 if form.has_key("NEUTRALC"): options["neutralc"] = 1 if form.has_key("LIGAND"): if have_opal: ligandfilename=str(form["LIGAND"].filename) ligandfilename=re.split(r'[/\\]',ligandfilename)[-1] # for Windows-style newline compatibility templigandfilename = tempfile.mkstemp()[1] templigandfile = open(templigandfilename,'w') templigandfile.write(form["LIGAND"].value) templigandfile.close() templigandfile = open(templigandfilename,'rU') if have_opal: options["ligand"] = templigandfile.read() else: templigandstring = templigandfile.read() # this variable is used again later to write this file to output options["ligand"] = StringIO(templigandstring) templigandfile.close() if not have_opal: pdbfilestring = pdbfile.read() pdblist, errlist = readPDB(StringIO(pdbfilestring)) dummydef = Definition() dummyprot = Protein(pdblist, dummydef) if len(pdblist) == 0 and len(errlist) == 0: text = "Unable to find PDB file - Please make sure this is " text += "a valid PDB file ID!" #print "Content-type: text/html\n" print text sys.exit(2) elif dummyprot.numAtoms() > MAXATOMS and "opt" in options: text = "<HTML><HEAD>" text += "<TITLE>PDB2PQR Error</title>" text += "<link rel=\"stylesheet\" href=\"%s\" type=\"text/css\">" % STYLESHEET text += "</HEAD><BODY><H2>PDB2PQR Error</H2><P>" text += "Due to server limits, we are currently unable to optimize " text += "proteins of greater than MAXATOMS atoms on the server (PDB2PQR " text += "found %s atoms in the selected PDB file). If you " % dummyprot.numAtoms() text += "want to forgo optimization please try the server again.<P>" text += "Otherwise you may use the standalone version of PDB2PQR that " text += "is available from the <a href=\"http://pdb2pqr.sourceforge.net\">" text += "PDB2PQR SourceForge project page</a>." text += "<script type=\"text/javascript\">" text += "var gaJsHost = ((\"https:\" == document.location.protocol) ? \"https://ssl.\" : \"http://www.\");" text += "document.write(unescape(\"%3Cscript src=\'\" + gaJsHost + \"google-analytics.com/ga.js\' type=\'text/javascript\'%3E%3C/script%3E\"));" text += "</script>" text += "<script type=\"text/javascript\">" text += "try {" text += "var pageTracker = _gat._getTracker(\"UA-11026338-3\");" for key in options: text += "pageTracker._trackPageview(\"/main_cgi/has_%s_%s.html\");" % (key, options[key]) text += "pageTracker._trackPageview();" text += "} catch(err) {}</script>" text += "</BODY></HTML>" #print "Content-type: text/html\n" print text sys.exit(2) try: if have_opal: ligandFile=None ffFile=None namesFile=None #else: starttime = time.time() name = setID(starttime) os.makedirs('%s%s%s' % (INSTALLDIR, TMPDIR, name)) apbsInputFile = open('%s%s%s/apbs_input' % (INSTALLDIR, TMPDIR, name),'w') apbsInputFile.write(str(apbs_input)) apbsInputFile.close() typemapInputFile = open('%s%s%s/typemap' % (INSTALLDIR, TMPDIR, name),'w') typemapInputFile.write(str(typemap)) typemapInputFile.close() if have_opal: myopts="" for key in options: if key=="opt": if options[key]==0: # user does not want optimization key="noopt" else: # pdb2pqr optimizes by default, don't bother with flag continue elif key=="debump": if options[key]==0: # user does not want debumping key="nodebump" else: # pdb2pqr debumps by default, so change this flag to --nodebump continue elif key=="ph": val=options[key] key="with-ph=%s" % val elif key=="ffout": val=options[key] key="ffout=%s" % val elif key=="ligand": val=ligandfilename key="ligand=%s" % val ligandFile = ns0.InputFileType_Def('inputFile') ligandFile._name = val ligandFile._contents = options["ligand"] elif key=="apbs": key="apbs-input" elif key=="chain": key="chain" elif key=="whitespace": key="whitespace" elif key=="typemap": key="typemap" elif key=="ff": val=options[key] key="ff=%s" % val if fffile: ffFile = ns0.InputFileType_Def('inputFile') ffFile._name = val + ".DAT" ffFileString = fffile.read() ffFile._contents = ffFileString if namesfile: namesFile = ns0.InputFileType_Def('inputFile') namesFile._name = val + ".names" namesFileString = namesfile.read() namesFile._contents = namesFileString if key not in ["userff", "usernames"]: myopts+="--"+str(key)+" " myopts+=str(pdbfilename)+" " if pdbfilename[-4:]==".pdb": myopts+="%s.pqr" % str(pdbfilename[:-4]) else: myopts+="%s.pqr" % str(pdbfilename) appLocator = AppServiceLocator() appServicePort = appLocator.getAppServicePort(PDB2PQR_OPAL_URL) # launch job req = launchJobRequest() req._argList = myopts inputFiles = [] pdbOpalFile = ns0.InputFileType_Def('inputFile') pdbOpalFile._name = pdbfilename pdbOpalFile._contents = pdbfile.read() pdbfile.close() inputFiles.append(pdbOpalFile) if ligandFile: inputFiles.append(ligandFile) if ffFile: inputFiles.append(ffFile) if namesFile: inputFiles.append(namesFile) req._inputFile=inputFiles try: resp=appServicePort.launchJob(req) except Exception, e: printHeader("PDB2PQR Job Submission - Error") print "<BODY>\n<P>" print "There was an error with your job submission<br>" print "</P>" print "<script type=\"text/javascript\">" print "var gaJsHost = ((\"https:\" == document.location.protocol) ? \"https://ssl.\" : \"http://www.\");" print "document.write(unescape(\"%3Cscript src=\'\" + gaJsHost + \"google-analytics.com/ga.js\' type=\'text/javascript\'%3E%3C/script%3E\"));" print "</script>" print "<script type=\"text/javascript\">" print "try {" print "var pageTracker = _gat._getTracker(\"UA-11026338-3\");" for key in options: print "pageTracker._trackPageview(\"/main_cgi/has_%s_%s.html\");" % (key, options[key]) print "pageTracker._trackPageview();" print "} catch(err) {}</script>" print "</BODY>" print "</HTML>" sys.exit(2) #printHeader("PDB2PQR Job Submission",have_opal,jobid=resp._jobID) pdb2pqrOpalJobIDFile = open('%s%s%s/pdb2pqr_opal_job_id' % (INSTALLDIR, TMPDIR, name), 'w') pdb2pqrOpalJobIDFile.write(resp._jobID) pdb2pqrOpalJobIDFile.close() print redirector(name) if options.has_key("userff"): options["userff"] = ffFileString if options.has_key("usernames"): options["usernames"] = namesFileString # Recording CGI run information for PDB2PQR Opal pdb2pqrOpalLogFile = open('%s%s%s/pdb2pqr_opal_log' % (INSTALLDIR, TMPDIR, name), 'w') pdb2pqrOpalLogFile.write(str(options)+'\n'+str(ff)+'\n'+str(os.environ["REMOTE_ADDR"])) pdb2pqrOpalLogFile.close() else:
def detail(request): if request.method == 'POST': form = ImageUploadForm(request.POST, request.FILES) if form.is_valid(): p = Project() p.name = form.cleaned_data['name'] p. architect = form.cleaned_data['architect'] p.image_file = form.cleaned_data['image'] p.save() image_file = request.FILES['image'] image_str = '' for c in image_file.chunks(): image_str += c image_file_strio = StringIO(image_str) image = PImage.open(image_file_strio) if image.mode != "RGB": image = image.convert('RGB') width, height = image.size print "Original image: %s x %s" %(width, height) wh_ratio = float(width) / float(height) print "wh_ratio: %s " %wh_ratio if wh_ratio > 4.0/3.0 and height > 300: print "Horizontal image" ratio = 300.0 / float(height) print "ratio: %s" %ratio image.thumbnail((int(ceil(width * ratio)), 300), PImage.ANTIALIAS) width, height = image.size print "Thumbnail image: %s x %s" %(width, height) cropped_image = image.crop((int(width / 2) - 200, 0, int(width / 2) + 200, 300)) print "Cropped: %s x %s" %cropped_image.size else: if width > 400: ratio = 400.0 / float(width) image.thumbnail((400, int(ceil(height * ratio))), PImage.ANTIALIAS) width, height = image.size cropped_image = image.crop((0, int(height / 2) - 150, 400, int(height / 2) + 150)) else: cropped_image = image filename, ext = os.path.splitext(p.image_file.name) thumb_filename = settings.MEDIA_ROOT + filename + "-thumb" + ext #cropped_image.save(thumb_filename, "JPEG") f = StringIO() try: cropped_image.save(f, format='jpeg') s = f.getvalue() print type(p.thumbnail_file) p.thumbnail_file.save(thumb_filename, ContentFile(s)) p.save() finally: f.close() return HttpResponseRedirect('/') else: form = ImageUploadForm() return render(request, 'arkiwimain/detail.html', {'form': form })
def mainCGI(): """ Main driver for running PDB2PQR from a web page """ import cgi import cgitb cgitb.enable() form = cgi.FieldStorage() options = {"extensions": {}} ff = form["FF"].value input = 0 if form.has_key("DEBUMP"): options["debump"] = 1 if form.has_key("OPT"): options["opt"] = 1 if form.has_key("PROPKA"): try: ph = float(form["PH"].value) if ph < 0.0 or ph > 14.0: raise ValueError options["ph"] = ph except ValueError: text = "The entered pH of %.2f is invalid! " % form["PH"].value text += "Please choose a pH between 0.0 and 14.0." print "Content-type: text/html\n" print text sys.exit(2) if form.has_key("PDBID"): file = getPDBFile(form["PDBID"].value) elif form.has_key("PDB"): file = StringIO(form["PDB"].value) if form.has_key("INPUT"): input = 1 options["apbs"] = 1 if form.has_key("USERFF"): userff = StringIO(form["USERFF"].value) ff = "user-defined" options["userff"] = userff if form.has_key("FFOUT"): if form["FFOUT"].value != "internal": options["ffout"] = form["FFOUT"].value if form.has_key("CHAIN"): options["chain"] = 1 if form.has_key("LIGAND"): options["ligand"] = StringIO(form["LIGAND"].value) pdblist, errlist = readPDB(file) if len(pdblist) == 0 and len(errlist) == 0: text = "Unable to find PDB file - Please make sure this is " text += "a valid PDB file ID!" print "Content-type: text/html\n" print text sys.exit(2) elif len(pdblist) > 10000 and "opt" in options: text = "<HTML><HEAD>" text += "<TITLE>PDB2PQR Error</title>" text += "<link rel=\"stylesheet\" href=\"%s\" type=\"text/css\">" % STYLESHEET text += "</HEAD><BODY><H2>PDB2PQR Error</H2><P>" text += "Due to server limits, we are currently unable to optimize " text += "proteins of greater than 10000 atoms on the server. If you " text += "want to forgo optimization please try the server again.<P>" text += "Otherwise you may use the standalone version of PDB2PQR that " text += "is available from the <a href=\"http://pdb2pqr.sourceforge.net\">" text += "PDB2PQR SourceForge project page</a>." text += "</BODY></HTML>" print "Content-type: text/html\n" print text sys.exit(2) try: starttime = time.time() name = setID(starttime) pqrpath = startServer(name) options["outname"] = pqrpath header, lines, missedligands = runPDB2PQR(pdblist, ff, options) file = open(pqrpath, "w") file.write(header) for line in lines: file.write("%s\n" % string.strip(line)) file.close() if input: from src import inputgen from src import psize method = "mg-auto" size = psize.Psize() size.parseInput(pqrpath) size.runPsize(pqrpath) async = 0 # No async files here! myinput = inputgen.Input(pqrpath, size, method, async) myinput.printInputFiles() endtime = time.time() - starttime createResults(header, input, name, endtime, missedligands) logRun(options, endtime, len(lines), ff, os.environ["REMOTE_ADDR"]) except StandardError, details: print "Content-type: text/html\n" print details createError(name, details)
err_handler("error sending message, returning it to host", pop, smtp) try: smtp.mail_to(user) except: err_handler("error sending message, returning it to host", pop, smtp) try: smtp.data(msg) except: err_handler("error sending message, returning it to host", pop, smtp) f.close() try: pop.delete(msgnum) except: err_handler("error deleting message %d" % msgnum, pop, smtp) pop.close() smtp.close() def err_handler(errmsg, pop, smtp): sys.stderr.write(sys.argv[1] + ": " + errmsg) pop.reset() pop.close() smtp.close()
def do_POST(self): try: eyeFiLogger.debug(self.command + " " + self.path + " " + self.request_version) SOAPAction = "" contentLength = "" # Loop through all the request headers and pick out ones that are relevant eyeFiLogger.debug("Headers received in POST request:") for headerName in self.headers.keys(): for headerValue in self.headers.getheaders(headerName): if (headerName == "soapaction"): SOAPAction = headerValue if (headerName == "content-length"): contentLength = int(headerValue) eyeFiLogger.debug(headerName + ": " + headerValue) # Read contentLength bytes worth of data eyeFiLogger.debug("Attempting to read " + str(contentLength) + " bytes of data") try: from StringIO import StringIO import tempfile except ImportError: eyeFiLogger.debug("No StringIO module") chunksize = 1048576 # 1MB mem = StringIO() while 1: remain = contentLength - mem.tell() if remain <= 0: break chunk = self.rfile.read(min(chunksize, remain)) if not chunk: break mem.write(chunk) postData = mem.getvalue() mem.close() eyeFiLogger.debug("Finished reading " + str(contentLength) + " bytes of data") # Perform action based on path and SOAPAction # A SOAPAction of StartSession indicates the beginning of an EyeFi # authentication request if ((self.path == "/api/soap/eyefilm/v1") and (SOAPAction == "\"urn:StartSession\"")): eyeFiLogger.debug("Got StartSession request") response = self.startSession(postData) contentLength = len(response) eyeFiLogger.debug("StartSession response: " + response) self.send_response(200) self.send_header('Date', self.date_time_string()) self.send_header('Pragma', 'no-cache') self.send_header('Server', 'Eye-Fi Agent/2.0.4.0 (Windows XP SP2)') self.send_header('Content-Type', 'text/xml; charset="utf-8"') self.send_header('Content-Length', contentLength) self.end_headers() self.wfile.write(response) self.wfile.flush() self.handle_one_request() # GetPhotoStatus allows the card to query if a photo has been uploaded # to the server yet if ((self.path == "/api/soap/eyefilm/v1") and (SOAPAction == "\"urn:GetPhotoStatus\"")): eyeFiLogger.debug("Got GetPhotoStatus request") response = self.getPhotoStatus(postData) contentLength = len(response) eyeFiLogger.debug("GetPhotoStatus response: " + response) self.send_response(200) self.send_header('Server', 'Eye-Fi UnderTheSea OSX/3.0.2') self.send_header('Connection', 'Keep-Alive') self.send_header('Keep-Alive', 'timeout=300, max=10') self.send_header('Date', self.date_time_string()) self.send_header('Content-Type', 'text/xml; charset="utf-8"') self.send_header('Content-Length', contentLength) self.end_headers() self.wfile.write(response) self.wfile.flush() # If the URL is upload and there is no SOAPAction the card is ready to send a picture to me if ((self.path == "/api/soap/eyefilm/v1/upload") and (SOAPAction == "")): eyeFiLogger.debug("Got upload request") response = self.uploadPhoto(postData) contentLength = len(response) eyeFiLogger.debug("Upload response: " + response) self.send_response(200) self.send_header('Date', self.date_time_string()) self.send_header('Pragma', 'no-cache') self.send_header('Server', 'Eye-Fi Agent/2.0.4.0 (Windows XP SP2)') self.send_header('Content-Type', 'text/xml; charset="utf-8"') self.send_header('Content-Length', contentLength) self.end_headers() self.wfile.write(response) self.wfile.flush() # If the URL is upload and SOAPAction is MarkLastPhotoInRoll if ((self.path == "/api/soap/eyefilm/v1") and (SOAPAction == "\"urn:MarkLastPhotoInRoll\"")): eyeFiLogger.debug("Got MarkLastPhotoInRoll request") response = self.markLastPhotoInRoll(postData) contentLength = len(response) eyeFiLogger.debug("MarkLastPhotoInRoll response: " + response) self.send_response(200) self.send_header('Date', self.date_time_string()) self.send_header('Pragma', 'no-cache') self.send_header('Server', 'Eye-Fi Agent/2.0.4.0 (Windows XP SP2)') self.send_header('Content-Type', 'text/xml; charset="utf-8"') self.send_header('Content-Length', contentLength) self.send_header('Connection', 'Close') self.end_headers() self.wfile.write(response) self.wfile.flush() eyeFiLogger.debug("Connection closed.") except: eyeFiLogger.error("Got an an exception:") eyeFiLogger.error(traceback.format_exc()) raise
def mainCGI(): """ Opal driver for running PDB2PQR from a web page """ serviceURL = OPALURL cgitb.enable() form = cgi.FieldStorage() options = {} ff = form["FF"].value options["ff"] = ff fffile = None input = 0 if form.has_key("DEBUMP"): options["debump"] = 1 else: options["debump"] = 0 if form.has_key("OPT"): options["opt"] = 1 else: options["opt"] = 0 if form.has_key("PROPKA"): try: ph = float(form["PH"].value) if ph < 0.0 or ph > 14.0: raise ValueError options["ph"] = ph except ValueError: text = "The entered pH of %.2f is invalid! " % form["PH"].value text += "Please choose a pH between 0.0 and 14.0." # print "Content-type: text/html\n" print text sys.exit(2) if form.has_key("PDBID"): filename = form["PDBID"].value infile = getPDBFile(form["PDBID"].value) elif form.has_key("PDB"): filename = form["PDB"].filename filename=re.split(r'[/\\]',filename)[-1] infile = StringIO(form["PDB"].value) if form.has_key("INPUT"): input = 1 options["apbs"] = 1 if form.has_key("USERFF"): # userff = StringIO(form["USERFF"].value) # ff = "user-defined" # options["userff"] = userff ffname = form["USERFF"].filename ffname = re.split(r'[/\\]',ffname)[-1] fffile = StringIO(form["USERFF"].value) options["ff"] = ffname if form.has_key("FFOUT"): if form["FFOUT"].value != "internal": options["ffout"] = form["FFOUT"].value if form.has_key("CHAIN"): options["chain"] = 1 if form.has_key("WHITESPACE"): options["whitespace"] = 1 if form.has_key("LIGAND"): ligandfilename=str(form["LIGAND"].filename) ligandfilename=re.split(r'[/\\]',ligandfilename)[-1] options["ligand"] = StringIO(form["LIGAND"].value) try: # starttime = time.time() # name = setID(starttime) name = filename ligandFile=None ffFile=None # begin SOAP changes # need to switch options from a dictionary to something resembling a command line query # such as --chain myopts="" for key in options: if key=="opt": if options[key]==0: # user does not want optimization key="noopt" else: # pdb2pqr optimizes by default, don't bother with flag continue elif key=="debump": if options[key]==0: # user does not want debumping key="nodebump" else: # pdb2pqr debumps by default, so change this flag to --nodebump continue elif key=="ph": val=options[key] key="with-ph=%s" % val elif key=="ffout": val=options[key] key="ffout=%s" % val elif key=="ligand": val=ligandfilename key="ligand=%s" % val ligandFile = ns0.InputFileType_Def('inputFile') ligandFile._name = val ligandFileTemp = open(options["ligand"], "r") ligandFileString = ligandFileTemp.read() ligandFileTemp.close() ligandFile._contents = ligandFileString elif key=="apbs": key="apbs-input" elif key=="chain": key="chain" elif key=="whitespace": key="whitespace" elif key=="ff": val=options[key] key="ff=%s" % val if fffile: ffFile = ns0.InputFileType_Def('inputFile') ffFile._name = val ffFileTemp = open(fffile, "r") ffFileString = ffFileTemp.read() ffFileTemp.close() ffFile._contents = ffFileString myopts+="--"+str(key)+" " myopts+=str(filename)+" " myopts+="%s.pqr" % str(name) appLocator = AppServiceLocator() appServicePort = appLocator.getAppServicePort(serviceURL) # launch job req = launchJobRequest() req._argList = myopts inputFiles = [] pdbFile = ns0.InputFileType_Def('inputFile') pdbFile._name = filename pdbFile._contents = infile.read() infile.close() inputFiles.append(pdbFile) if ligandFile: inputFiles.append(ligandFile) if ffFile: inputFiles.append(ffFile) req._inputFile=inputFiles try: resp=appServicePort.launchJob(req) except Exception, e: printheader("PDB2PQR Job Submission - Error") print "<BODY>\n<P>" print "There was an error with your job submission<br>" print "</P>\n</BODY>" print "</HTML>" sys.exit(2) printheader("PDB2PQR Job Submission",resp._jobID)
def do_POST(self): try: eyeFiLogger.debug(self.command + " " + self.path + " " + self.request_version) SOAPAction = "" contentLength = "" # Loop through all the request headers and pick out ones that are relevant eyeFiLogger.debug("Headers received in POST request:") for headerName in self.headers.keys(): for headerValue in self.headers.getheaders(headerName): if( headerName == "soapaction"): SOAPAction = headerValue if( headerName == "content-length"): contentLength = int(headerValue) eyeFiLogger.debug(headerName + ": " + headerValue) # Read contentLength bytes worth of data eyeFiLogger.debug("Attempting to read " + str(contentLength) + " bytes of data") # postData = self.rfile.read(contentLength) try: from StringIO import StringIO import tempfile except ImportError: eyeFiLogger.debug("No StringIO module") chunksize = 1048576 # 1MB mem = StringIO() while 1: remain = contentLength - mem.tell() if remain <= 0: break chunk = self.rfile.read(min(chunksize, remain)) if not chunk: break mem.write(chunk) print remain print "Finished" postData = mem.getvalue() mem.close() eyeFiLogger.debug("Finished reading " + str(contentLength) + " bytes of data") # Perform action based on path and SOAPAction # A SOAPAction of StartSession indicates the beginning of an EyeFi # authentication request if((self.path == "/api/soap/eyefilm/v1") and (SOAPAction == "\"urn:StartSession\"")): eyeFiLogger.debug("Got StartSession request") response = self.startSession(postData) contentLength = len(response) eyeFiLogger.debug("StartSession response: " + response) self.send_response(200) self.send_header('Date', self.date_time_string()) self.send_header('Pragma','no-cache') self.send_header('Server','Eye-Fi Agent/2.0.4.0 (Windows XP SP2)') self.send_header('Content-Type','text/xml; charset="utf-8"') self.send_header('Content-Length', contentLength) self.end_headers() self.wfile.write(response) self.wfile.flush() self.handle_one_request() # GetPhotoStatus allows the card to query if a photo has been uploaded # to the server yet if((self.path == "/api/soap/eyefilm/v1") and (SOAPAction == "\"urn:GetPhotoStatus\"")): eyeFiLogger.debug("Got GetPhotoStatus request") response = self.getPhotoStatus(postData) contentLength = len(response) eyeFiLogger.debug("GetPhotoStatus response: " + response) self.send_response(200) self.send_header('Date', self.date_time_string()) self.send_header('Pragma','no-cache') self.send_header('Server','Eye-Fi Agent/2.0.4.0 (Windows XP SP2)') self.send_header('Content-Type','text/xml; charset="utf-8"') self.send_header('Content-Length', contentLength) self.end_headers() self.wfile.write(response) self.wfile.flush() # If the URL is upload and there is no SOAPAction the card is ready to send a picture to me if((self.path == "/api/soap/eyefilm/v1/upload") and (SOAPAction == "")): eyeFiLogger.debug("Got upload request") response = self.uploadPhoto(postData) contentLength = len(response) eyeFiLogger.debug("Upload response: " + response) self.send_response(200) self.send_header('Date', self.date_time_string()) self.send_header('Pragma','no-cache') self.send_header('Server','Eye-Fi Agent/2.0.4.0 (Windows XP SP2)') self.send_header('Content-Type','text/xml; charset="utf-8"') self.send_header('Content-Length', contentLength) self.end_headers() self.wfile.write(response) self.wfile.flush() # If the URL is upload and SOAPAction is MarkLastPhotoInRoll if((self.path == "/api/soap/eyefilm/v1") and (SOAPAction == "\"urn:MarkLastPhotoInRoll\"")): eyeFiLogger.debug("Got MarkLastPhotoInRoll request") response = self.markLastPhotoInRoll(postData) contentLength = len(response) eyeFiLogger.debug("MarkLastPhotoInRoll response: " + response) self.send_response(200) self.send_header('Date', self.date_time_string()) self.send_header('Pragma','no-cache') self.send_header('Server','Eye-Fi Agent/2.0.4.0 (Windows XP SP2)') self.send_header('Content-Type','text/xml; charset="utf-8"') self.send_header('Content-Length', contentLength) self.send_header('Connection', 'Close') self.end_headers() self.wfile.write(response) self.wfile.flush() eyeFiLogger.debug("Connection closed.") except: eyeFiLogger.error("Got an an exception:") eyeFiLogger.error(traceback.format_exc()) raise
def mainCGI(): """ Main driver for running PDB2PQR from a web page """ import cgi import cgitb cgitb.enable() form = cgi.FieldStorage() options = {} ff = form["FF"].value input = 0 if form.has_key("DEBUMP"): options["debump"] = 1 if form.has_key("OPT"): options["opt"] = 1 if form.has_key("PROPKA"): try: ph = float(form["PH"].value) if ph < 0.0 or ph > 14.0: raise ValueError options["ph"] = ph except ValueError: text = "The entered pH of %.2f is invalid! " % form["PH"].value text += "Please choose a pH between 0.0 and 14.0." print "Content-type: text/html\n" print text sys.exit(2) if form.has_key("PDBID"): file = getFile(form["PDBID"].value) elif form.has_key("PDB"): file = StringIO(form["PDB"].value) if form.has_key("INPUT"): input = 1 pdblist, errlist = readPDB(file) if len(pdblist) == 0 and len(errlist) == 0: text = "Unable to find PDB file - Please make sure this is " text += "a valid PDB file ID!" print "Content-type: text/html\n" print text sys.exit(2) elif len(pdblist) > 10000 and "opt" in options: text = "<HTML><HEAD>" text += "<TITLE>PDB2PQR Error</title>" text += "<link rel=\"stylesheet\" href=\"%s\" type=\"text/css\">" % STYLESHEET text += "</HEAD><BODY><H2>PDB2PQR Error</H2><P>" text += "Due to server limits, we are currently unable to optimize " text += "proteins of greater than 10000 atoms on the server. If you " text += "want to forgo optimization please try the server again.<P>" text += "Otherwise you may use the standalone version of PDB2PQR that " text += "is available from the <a href=\"http://pdb2pqr.sourceforge.net\">" text += "PDB2PQR SourceForge project page</a>." text += "</BODY></HTML>" print "Content-type: text/html\n" print text sys.exit(2) try: starttime = time.time() name = setID(starttime) pqrpath = startServer(name) options["outname"] = pqrpath header, lines = runPDB2PQR(pdblist, ff, options) file = open(pqrpath, "w") file.write(header) for line in lines: file.write("%s\n" % string.strip(line)) file.close() if input: from src import inputgen from src import psize method = "mg-auto" size = psize.Psize() size.parseInput(pqrpath) size.runPsize(pqrpath) async = 0 # No async files here! myinput = inputgen.Input(pqrpath, size, method, async) myinput.printInputFiles() endtime = time.time() - starttime createResults(header, input, name, endtime) logRun(form, endtime, len(pdblist)) except StandardError, details: print "Content-type: text/html\n" print details createError(name, details)
def _do_actions(self, context, actions): # Get API component. api = self.env[ScreenshotsApi] for action in actions: if action == 'get-file': context.req.perm.assert_permission('SCREENSHOTS_VIEW') # Get request arguments. screenshot_id = int(context.req.args.get('id') or 0) format = context.req.args.get('format') or self.default_format width = int(context.req.args.get('width') or 0) height = int(context.req.args.get('height') or 0) # Check if requested format is allowed. if not format in self.formats: raise TracError(_("Requested screenshot format that is not " "allowed."), _("Requested format not allowed.")) # Get screenshot. screenshot = api.get_screenshot(context, screenshot_id) # Check if requested screenshot exists. if not screenshot: if context.req.perm.has_permission('SCREENSHOTS_ADD'): context.req.redirect(context.req.href.screenshots( action = 'add')) else: raise TracError(_("Screenshot not found.")) # Set missing dimensions. width = width or screenshot['width'] height = height or screenshot['height'] if format == 'html': # Format screenshot for presentation. screenshot['author'] = format_to_oneliner(self.env, context, screenshot['author']) screenshot['name'] = format_to_oneliner(self.env, context, screenshot['name']) screenshot['description'] = format_to_oneliner(self.env, context, screenshot['description']) screenshot['time'] = pretty_timedelta(to_datetime( screenshot['time'], utc)) # For HTML preview format return template. context.req.data['screenshot'] = screenshot return ('screenshot', None) else: # Prepare screenshot filename. name, ext = os.path.splitext(screenshot['file']) format = (format == 'raw') and ext or '.' + format path = os.path.normpath(os.path.join(self.path, to_unicode( screenshot['id']))) filename = os.path.normpath(os.path.join(path, '%s-%sx%s%s' % (name, width, height, format))) orig_name = os.path.normpath(os.path.join(path, '%s-%sx%s%s' % (name, screenshot['width'], screenshot['height'], ext))) base_name = os.path.normpath(os.path.basename(filename)) self.log.debug('filename: %s' % (filename,)) # Create requested file from original if not exists. if not os.path.isfile(filename.encode('utf-8')): self._create_image(orig_name, path, name, format, width, height) # Guess mime type. file = open(filename.encode('utf-8'), "r") file_data = file.read(1000) file.close() mimeview = Mimeview(self.env) mime_type = mimeview.get_mimetype(filename, file_data) if not mime_type: mime_type = 'application/octet-stream' if 'charset=' not in mime_type: charset = mimeview.get_charset(file_data, mime_type) mime_type = mime_type + '; charset=' + charset # Send file to request. context.req.send_header('Content-Disposition', 'attachment;filename="%s"' % (base_name)) context.req.send_header('Content-Description', screenshot['description']) context.req.send_file(filename.encode('utf-8'), mime_type) elif action == 'add': context.req.perm.assert_permission('SCREENSHOTS_ADD') # Get request arguments. index = int(context.req.args.get('index') or 0) # Fill data dictionary. context.req.data['index'] = index context.req.data['versions'] = api.get_versions(context) context.req.data['components'] = api.get_components(context) # Return template with add screenshot form. return ('screenshot-add', None) elif action == 'post-add': context.req.perm.assert_permission('SCREENSHOTS_ADD') # Get image file from request. file, filename = self._get_file_from_req(context.req) name, ext = os.path.splitext(filename) ext = ext.lower() filename = name + ext # Is uploaded file archive or single image? if ext == '.zip': # Get global timestamp for all files in archive. timestamp = to_timestamp(datetime.now(utc)) # List files in archive. zip_file = ZipFile(file) for filename in zip_file.namelist(): # Test file extensions for supported type. name, ext = os.path.splitext(filename) tmp_ext = ext.lower()[1:] if tmp_ext in self.ext and tmp_ext != 'zip': # Decompress image file data = zip_file.read(filename) file = StringIO(data) filename = to_unicode(os.path.basename(filename)) # Screenshots must be identified by timestamp. timestamp += 1 # Create image object. image = Image.open(file) # Construct screenshot dictionary from form values. screenshot = {'name' : context.req.args.get('name'), 'description' : context.req.args.get('description'), 'time' : timestamp, 'author' : context.req.authname, 'tags' : context.req.args.get('tags'), 'file' : filename, 'width' : image.size[0], 'height' : image.size[1], 'priority' : int(context.req.args.get('priority') or '0')} self.log.debug('screenshot: %s' % (screenshot,)) # Save screenshot file and add DB entry. self._add_screenshot(context, api, screenshot, file) zip_file.close() else: # Create image object. image = Image.open(file) # Construct screenshot dictionary from form values. screenshot = {'name' : context.req.args.get('name'), 'description' : context.req.args.get('description'), 'time' : to_timestamp(datetime.now(utc)), 'author' : context.req.authname, 'tags' : context.req.args.get('tags'), 'file' : filename, 'width' : image.size[0], 'height' : image.size[1], 'priority' : int(context.req.args.get('priority') or '0')} self.log.debug('screenshot: %s' % (screenshot,)) # Add single image. self._add_screenshot(context, api, screenshot, file) # Close input file. file.close() # Clear ID to prevent display of edit and delete button. context.req.args['id'] = None elif action == 'edit': context.req.perm.assert_permission('SCREENSHOTS_EDIT') # Get request arguments. screenshot_id = context.req.args.get('id') # Prepare data dictionary. context.req.data['screenshot'] = api.get_screenshot(context, screenshot_id) elif action == 'post-edit': context.req.perm.assert_permission('SCREENSHOTS_EDIT') # Get screenshot arguments. screenshot_id = int(context.req.args.get('id') or 0) # Get old screenshot old_screenshot = api.get_screenshot(context, screenshot_id) # Check if requested screenshot exits. if not old_screenshot: raise TracError(_("Edited screenshot not found."), _("Screenshot not found.")) # Get image file from request. image = context.req.args['image'] if hasattr(image, 'filename') and image.filename: in_file, filename = self._get_file_from_req(context.req) name, ext = os.path.splitext(filename) filename = name + ext.lower() else: filename = None # Construct screenshot dictionary from form values. screenshot = {'name' : context.req.args.get('name'), 'description' : context.req.args.get('description'), 'author' : context.req.authname, 'tags' : context.req.args.get('tags'), 'components' : context.req.args.get('components') or [], 'versions' : context.req.args.get('versions') or [], 'priority' : int(context.req.args.get('priority') or '0')} # Update dimensions and filename if image file is updated. if filename: image = Image.open(in_file) screenshot['file'] = filename screenshot['width'] = image.size[0] screenshot['height'] = image.size[1] # Convert components and versions to list if only one item is # selected. if not isinstance(screenshot['components'], list): screenshot['components'] = [screenshot['components']] if not isinstance(screenshot['versions'], list): screenshot['versions'] = [screenshot['versions']] self.log.debug('screenshot: %s' % (screenshot)) # Edit screenshot. api.edit_screenshot(context, screenshot_id, screenshot) # Prepare file paths. if filename: name, ext = os.path.splitext(screenshot['file']) path = os.path.normpath(os.path.join(self.path, to_unicode( screenshot_id))) filepath = os.path.normpath(os.path.join(path, '%s-%ix%i%s' % (name, screenshot['width'], screenshot['height'], ext))) self.log.debug('path: %s' % (path,)) self.log.debug('filepath: %s' % (filepath,)) # Delete present images. try: for file in os.listdir(path): file = os.path.normpath(os.path.join(path, to_unicode(file))) os.remove(file.encode('utf-8')) except Exception, error: raise TracError(_("Error deleting screenshot. Original " "error message was: %s""") % (to_unicode(error),)) # Store uploaded image. try: out_file = open(filepath.encode('utf-8'), 'wb+') in_file.seek(0) shutil.copyfileobj(in_file, out_file) out_file.close() except Exception, error: try: os.remove(filepath.encode('utf-8')) except: pass raise TracError(_("Error storing file. Is directory " "specified in path config option in [screenshots] " "section of trac.ini existing? Original error " "message was: %s") % (to_unicode(error),)) # Notify change listeners. for listener in self.change_listeners: listener.screenshot_changed(context.req, screenshot, old_screenshot) # Clear ID to prevent display of edit and delete button. context.req.args['id'] = None
def true_close(self): return StringIO.close(self)
from urllib2 import * import StringIO #password_mgr = HTTPPasswordMgrWithDefaultRealm() url = "https://stream.twitter.com/1/statuses/sample.json" password_mgr.add_password(None, url, 'raspbmcbig33k', 'd0ggie') h = HTTPBasicAuthHandler(password_mgr) opener = build_opener(h) page = opener.open(url) io = StringIO(page.read()) print io.getvalue() io.close()
def do_POST(self): try: # eyeFiLogger.debug(self.command + " " + self.path + " " + self.request_version) SOAPAction = "" contentLength = "" # Loop through all the request headers and pick out ones that are relevant # eyeFiLogger.debug("Headers received in POST request:") for headerName in self.headers.keys(): for headerValue in self.headers.getheaders(headerName): if( headerName == "soapaction"): SOAPAction = headerValue if( headerName == "content-length"): contentLength = int(headerValue) # eyeFiLogger.debug(headerName + ": " + headerValue) # Read contentLength bytes worth of data # eyeFiLogger.debug("Attempting to read " + str(contentLength) + " bytes of data") # postData = self.rfile.read(contentLength) try: from StringIO import StringIO import tempfile except ImportError: eyeFiLogger.debug("No StringIO module") chunksize = 1048576 # 1MB mem = StringIO() while 1: remain = contentLength - mem.tell() if remain <= 0: break chunk = self.rfile.read(min(chunksize, remain)) if not chunk: break mem.write(chunk) print remain print "Finished" postData = mem.getvalue() mem.close() # eyeFiLogger.debug("Finished reading " + str(contentLength) + " bytes of data") # Perform action based on path and SOAPAction # A SOAPAction of StartSession indicates the beginning of an EyeFi authentication request if((self.path == "/api/soap/eyefilm/v1") and (SOAPAction == "\"urn:StartSession\"")): eyeFiLogger.debug("Got StartSession request") response = self.startSession(postData) contentLength = len(response) # eyeFiLogger.debug("StartSession response: " + response) self.send_response(200) self.send_header('Date', self.date_time_string()) self.send_header('Pragma','no-cache') self.send_header('Server','Eye-Fi Agent/2.0.4.0 (Windows XP SP2)') self.send_header('Content-Type','text/xml; charset="utf-8"') self.send_header('Content-Length', contentLength) self.end_headers() self.wfile.write(response) self.wfile.flush() self.handle_one_request() # GetPhotoStatus allows the card to query if a photo has been uploaded # to the server yet if((self.path == "/api/soap/eyefilm/v1") and (SOAPAction == "\"urn:GetPhotoStatus\"")): eyeFiLogger.debug("Got GetPhotoStatus request") response = self.getPhotoStatus(postData) contentLength = len(response) # eyeFiLogger.debug("GetPhotoStatus response: " + response) self.send_response(200) self.send_header('Date', self.date_time_string()) self.send_header('Pragma','no-cache') self.send_header('Server','Eye-Fi Agent/2.0.4.0 (Windows XP SP2)') self.send_header('Content-Type','text/xml; charset="utf-8"') self.send_header('Content-Length', contentLength) self.end_headers() self.wfile.write(response) self.wfile.flush() # If the URL is upload and there is no SOAPAction the card is ready to send a picture to me if((self.path == "/api/soap/eyefilm/v1/upload") and (SOAPAction == "")): # eyeFiLogger.debug("Got upload request") response = self.uploadPhoto(postData) contentLength = len(response) # eyeFiLogger.debug("Upload response: " + response) self.send_response(200) self.send_header('Date', self.date_time_string()) self.send_header('Pragma','no-cache') self.send_header('Server','Eye-Fi Agent/2.0.4.0 (Windows XP SP2)') self.send_header('Content-Type','text/xml; charset="utf-8"') self.send_header('Content-Length', contentLength) self.end_headers() self.wfile.write(response) self.wfile.flush() # If the URL is upload and SOAPAction is MarkLastPhotoInRoll if((self.path == "/api/soap/eyefilm/v1") and (SOAPAction == "\"urn:MarkLastPhotoInRoll\"")): # eyeFiLogger.debug("Got MarkLastPhotoInRoll request") response = self.markLastPhotoInRoll(postData) contentLength = len(response) # eyeFiLogger.debug("MarkLastPhotoInRoll response: " + response) self.send_response(200) self.send_header('Date', self.date_time_string()) self.send_header('Pragma','no-cache') self.send_header('Server','Eye-Fi Agent/2.0.4.0 (Windows XP SP2)') self.send_header('Content-Type','text/xml; charset="utf-8"') self.send_header('Content-Length', contentLength) self.send_header('Connection', 'Close') self.end_headers() self.wfile.write(response) self.wfile.flush() # --------------- # format upload size uploaded_str = human_size(self.server.session_upload_size) # elapsed time (secs) elapsed_time = time.time() - self.server.session_start_time # formated into HH:MM:SS elapsed_str = str(timedelta(seconds=elapsed_time)) eyeFiLogger.debug("upload complete: duration: " + elapsed_str + ", uploaded: " + str(self.server.session_counter) + ", size: " + uploaded_str + ", total(history): " + str(self.server.global_counter)) # (JP) send notification on upload complete subprocess.call(['/usr/local/bin/eyefi-notify.sh', str(self.server.session_counter), uploaded_str, self.server.session_files]) # reset session counters self.server.session_files = "" self.server.session_counter = 0 self.server.session_upload_size = 0 self.server.session_start_time = 0; # --------------- except: eyeFiLogger.error("Got an an exception:") eyeFiLogger.error(traceback.format_exc()) raise
def run_python_cmd(self, cmd, std_pipe=None, input_var=None, stdout=None, stderr=None): """ Function to execute a python command, accepting an input variable and returning: 1. Result of python command 2. stdout of python command 3. stderr of python command The python command is executed using exec(cmd, self.globals, self.local) in order to maintain a separate "variable space" from the Pybash program. Unlike run_shell_cmd(), run_python_cmd() is blocking. A future improvement could be to execute the python command in a subprocess, and allow streaming data through std_pipe. Args: cmd (str): the shell command to execute std_pipe (list): list used to pass [input_var, stdout, stderr] if all three are available / required input_var: The input variable to the python command, which acts similarily to stdin for a shell command. This may be: 1. File-like object (open python file or pipe), which will be read and converted to a string 2. Python variable that will be passed directly 3. None: no input is provided to the python command stdout: The destination of the result(s) of the python command. This may be: 1. File-like object (open python file or pipe), result(s) of python command will be written here 2. subprocess.PIPE: a new collections.deque object will be created and result(s) of python command will be written here 3. collections.deque object, result(s) of python command will be written here 4. None: stdout will be written to sys.stdout (i.e. the terminal) stderr: The destination of the standard error generated by the python command. This may be: 1. File-like object (open python file or pipe), stderr of python command will be written here 2. subprocess.PIPE: a new collections.deque object will be created and stderr of python command will be written here 3. collections.deque object, stderr of python command will be written here 4. None: stdout will be written to sys.stdout (i.e. the terminal) Returns: tuple: File-like objects for stdout, stderr (stdout, stderr, None) .. note:: Since run_python_cmd() does not execute in a subprocess, no process is returned by this function. stdout and stderr are collections.deque objects, which typically have only one element. Additional elements are added by using redirects. For example, you can redirect the command's stderr to the stdout deque object. The stdout deque may contain (one or both): a) the result of evaluating a python statement (e.g. if cmd = '2+4', stdout = 6) b) the stdout resulting from executing the python statement (e.g. if cmd = 'print("foo")', stdout = 'foo') For example, if executing a function that contains a print() statement as well as returning a value, the stdout deque will contain both the return value and the printed text. The stderr deque will contain the errors generated by the python command (e.g. exception text) """ # Expand the std_pipe, handle redirects (create deque objects instead of os.pipe()) input_var, stdout, stderr = pipe_util.expand_std_pipe( std_pipe, input_var, stdout, stderr) self.write_debug( "Expanded std_pipe: %s" % [type(input_var), stdout, stderr], "run_python_cmd") #################################################################### # Step 1) Get input data, initialize __inputvar__ and __outputvar__ in self.locals # If the input_data is a file descriptor, read string if input_var and pipe_util.isfile(input_var): self.write_debug( "Reading file object %s and storing as input_var" % input_var, "run_python_cmd") input_var = pipe_util.read_close_fd(input_var) # Initialize the special __inputvar__ variable # Python 3.x: Use globals so commands like '[@[f] for f in @] for' # Python 2.x Use locals since this does not seem to be a problem if sys.version_info >= (3, 0): self.globals['__inputvar__'] = input_var else: self.locals['__inputvar__'] = input_var # Initialize __outputvar__ to None in self.locals - may have been set by a previous cmd self.locals['__outputvar__'] = None #################################################################### # Step 2: Compile the command # a) Check to see if the command references the input variable if '@' in cmd: cmd = cmd.replace("@", "__inputvar__") # b) Check to see if this is command that can be assigned to a variable # - there is probably a better way to do this without using a try-catch # TODO: ugly nested try-catch try: assignment_cmd = "__outputvar__ = " + cmd # self.write_debug("test: %s" % assignment_cmd, "run_python_cmd") cmd_c = compile(assignment_cmd, '<pybash>', 'exec') cmd = assignment_cmd capture_output_var = True except (SyntaxError, TypeError) as e: # c) Attempt to compile original cmd try: cmd_c = compile(cmd, '<pybash>', 'exec') capture_output_var = False except (SyntaxError, TypeError) as e: self.print_error("Could not compile: %s" % cmd) self.stderr_write(str(e) + '\n') self.stderr_write(traceback.format_exc()) return None, None, None self.write_debug("Successfully compiled python: %s" % (cmd), "run_python_cmd") #################################################################### # Step 3: Execute the command # a) Create StringIO for out/error # - after doing this, don't print anything until out/err are restored! if sys.version_info >= (3, 0): out = StringIO() err = StringIO() else: out = StringIO.StringIO() err = StringIO.StringIO() # Capture out/err sys.stdout = out sys.stderr = err # b) run command in try-catch # - if any errors occur, they will get added to std_pipe[2] try: exec(cmd_c, self.globals, self.locals) except Exception as e: sys.stderr.write(str(e) + '\n') pass # c) restore orig out/err sys.stdout = sys.__stdout__ sys.stderr = sys.__stderr__ # get out/err values and close stdout_val = out.getvalue() stderr_val = err.getvalue() out.close() err.close() self.write_debug("Restored stdout/stderr", "run_python_cmd") #################################################################### # Step 4: Add output to pipe or print to sys.stdout/sys.stderr # Define source lists for output + error pipes # - __outputvar__ may not be defined if something went wrong try: stdout_src_list = [self.locals['__outputvar__'], stdout_val] except UnboundLocalError: stdout_src_list = [None, stdout_val] stderr_src_list = [stderr_val] # Define the mappings between the (name, output pipe, output print function, output source list) output_mapping = [ ("stdout", stdout, self.stdout_write, stdout_src_list), ("stderr", stderr, self.stderr_write, stderr_src_list) ] # Process each output mapping for name, pipe, print_fn, src_list in output_mapping: # Process each source in the list for src in src_list: if not src: continue # If pipe is a deque, appendleft if type(pipe) == deque: self.write_debug("Adding src to %s queue" % name, "run_python_cmd") pipe.appendleft(src) # If pipe is a file-like object, write to file elif pipe_util.isfile(pipe): self.write_debug( "Writing %s src to file %s" % (name, pipe), "run_python_cmd") pipe.write(pybash_helper.to_str(src)) # If pipe is None, print using print function elif pipe is None: self.write_debug( "Printing %s with function %s" % (name, print_fn), "run_python_cmd") print_fn(src) # Otherwise, unrecognized pipe type else: raise ValueError( "Unrecognized pipe type for %s: %s" % name, type(pipe)) # Close any open file handles and return output # - there is no subprocess for python commands output = [stdout, stderr, None] for i in range(2): if pipe_util.isfile(output[i]): if output[i].closed is False: output[i].close() # Replace with None so that run_cmd() knows not to expect anything output[i] = None return output
def true_close(self): return StringIO.close(self)