def testSimpleSerialization(self): from cStringIO import StringIO basic_turtle = """@prefix dc: <http://purl.org/dc/terms/> . @prefix example: <http://example.com/> . example:foo dc:title "Foo" . example:bar dc:title "Bar" . example:baz dc:subject example:foo .""" graph = self.turtle_parser.parse(basic_turtle) f = StringIO() self.profile.setPrefix('ex', self.primitives.NamedNode('http://example.com/')) self.profile.setPrefix('dc', self.primitives.NamedNode('http://purl.org/dc/terms/')) self.serialize_turtle(graph = graph, f = f, profile = self.profile) f.seek(0) graph2 = self.turtle_parser.parse(f.read()) f.seek(0) self.assertEqual(f.read().strip(), """@prefix ex: <http://example.com/> . @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix dc: <http://purl.org/dc/terms/> . ex:bar dc:title "Bar" ; . ex:baz dc:subject ex:foo ; . ex:foo dc:title "Foo" ; .""")
def testMultiplePredicates(self): from cStringIO import StringIO basic_turtle = """@prefix dc: <http://purl.org/dc/terms/> . @prefix example: <http://example.com/> . example:foo dc:title "Foo" ; dc:author "Bar" ; dc:subject example:yesfootoo . example:garply dc:title "Garply" ; dc:author "Baz" ; dc:subject example:thegarply .""" graph = self.turtle_parser.parse(basic_turtle) f = StringIO() self.profile.setPrefix('ex', self.primitives.NamedNode('http://example.com/')) self.profile.setPrefix('dc', self.primitives.NamedNode('http://purl.org/dc/terms/')) self.serialize_turtle(graph = graph, f = f, profile = self.profile) f.seek(0) graph2 = self.turtle_parser.parse(f.read()) f.seek(0) self.assertEqual(f.read().strip(), """@prefix ex: <http://example.com/> . @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix dc: <http://purl.org/dc/terms/> . ex:foo dc:author "Bar" ; dc:subject ex:yesfootoo ; dc:title "Foo" ; . ex:garply dc:author "Baz" ; dc:subject ex:thegarply ; dc:title "Garply" ; .""")
def save(self): if self.img_principal: image = Image.open(self.img_principal) if image.mode not in ('L', 'RGB'): image = image.convert('RGB') # for field_name, size in IMAGE_SIZES.iteritems(): # field = getattr(self, field_name) temp_handle = StringIO() img_tmp = image.resize(IMAGE_SIZES['img_principal'], Image.ANTIALIAS) img_tmp.save(temp_handle, 'png') temp_handle.seek(0) suf = SimpleUploadedFile(os.path.split(self.img_principal.name)[-1], temp_handle.read(), content_type='image/png') self.img_principal.save(suf.name, suf, save=False) img_tmp = image.resize(IMAGE_SIZES['thumb_g'], Image.ANTIALIAS) temp_handle = StringIO() img_tmp.save(temp_handle, 'png') temp_handle.seek(0) suf = SimpleUploadedFile(os.path.split(self.img_principal.name)[-1], temp_handle.read(), content_type='image/png') self.thumb_g.save(suf.name, suf, save=False) img_tmp = image.resize(IMAGE_SIZES['thumb_p'], Image.ANTIALIAS) temp_handle = StringIO() img_tmp.save(temp_handle, 'png') temp_handle.seek(0) suf = SimpleUploadedFile(os.path.split(self.img_principal.name)[-1], temp_handle.read(), content_type='image/png') self.thumb_p.save(suf.name, suf, save=False) if False: pass else: super(Peca, self).save()
def create_thumbnail(self): # Original code: http://snipt.net/danfreak/generate-thumbnails-in-django-with-pil/ # And http://www.yilmazhuseyin.com/blog/dev/create-thumbnails-imagefield-django/ converter = Converter(self.imageFile) image = converter.reduceSize() # Save the thumbnail temp_handle = StringIO() image.save(temp_handle, converter.PIL_TYPE) temp_handle.seek(0) suf = SimpleUploadedFile(os.path.split(self.imageFile.name)[-1], temp_handle.read(), content_type=converter.DJANGO_TYPE) # Save SimpleUploadedFile into image field self.imageThumbnailFile.save('%s_thumbnail.%s' % (os.path.splitext(suf.name)[0], converter.FILE_EXTENSION), suf, save=False) temp_handle = StringIO() squaredImage = converter.createCenteredSquare() squaredImage.save(temp_handle, converter.PIL_TYPE) temp_handle.seek(0) suf = SimpleUploadedFile(os.path.split(self.imageFile.name)[-1], temp_handle.read(), content_type=converter.DJANGO_TYPE) self.imageThumbnailSquaredFile.save('%s_thumbnail_squared.%s' % (os.path.splitext(suf.name)[0], converter.FILE_EXTENSION), suf, save=False) bwImage = squaredImage.convert("L") temp_handle = StringIO() bwImage.save(temp_handle, converter.PIL_TYPE) temp_handle.seek(0) suf = SimpleUploadedFile(os.path.split(self.imageFile.name)[-1], temp_handle.read(), content_type=converter.DJANGO_TYPE) self.imageThumbnailBWFile.save('%s_thumbnail_bw.%s' % (os.path.splitext(suf.name)[0], converter.FILE_EXTENSION), suf, save=False)
def save(self, force_insert=False, force_update=False, using=None, update_fields=None): try: if self.image.file is not None: img = Image.open(self.image.file) thumbnail = img.resize((settings.GUDFUD_USER_THUMBNAIL_WIDTH, settings.GUDFUD_USER_THUMBNAIL_HEIGHT), Image.ANTIALIAS) temp_handle_img = StringIO() img.save(temp_handle_img, 'jpeg') temp_handle_img.seek(0) temp_handle_thumbnail = StringIO() thumbnail.save(temp_handle_thumbnail, 'jpeg') temp_handle_thumbnail.seek(0) fname_thumbnail = str(self.id) + ".jpeg" suf_thumbnail = SimpleUploadedFile(fname_thumbnail, temp_handle_thumbnail.read(), content_type='image/jpeg') fname_img = str(self.id) + ".jpeg" suf_img = SimpleUploadedFile(fname_img, temp_handle_img.read(), content_type='image/jpeg') self.thumbnail_image.save(fname_thumbnail, suf_thumbnail, save=False) self.image.save(fname_img, suf_img, save=False) except ValueError: pass super(BaseUser, self).save(force_insert, force_update, using, update_fields)
def deserialize_tx_payload(self, data): msg = {} if type(data) is str: data = StringIO(data) msg['version'] = struct.unpack("<I", data.read(4))[0] msg['tx_in_count'] = self.deserialize_int(data) msg['tx_in'] = [] for _ in xrange(msg['tx_in_count']): tx_in = self.deserialize_tx_in(data) msg['tx_in'].append(tx_in) msg['tx_out_count'] = self.deserialize_int(data) msg['tx_out'] = [] for _ in xrange(msg['tx_out_count']): tx_out = self.deserialize_tx_out(data) msg['tx_out'].append(tx_out) msg['lock_time'] = struct.unpack("<I", data.read(4))[0] # Calculate hash from the entire payload payload = self.serialize_tx_payload(msg) msg['tx_hash'] = hexlify(sha256(sha256(payload))[::-1]) return msg
def extract( filename, dir ): """ Thank you very much! http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/465649 """ zf = zipfile.ZipFile( filename ) # make base pushd = os.getcwd() if not os.path.isdir( dir ): os.mkdir( dir ) os.chdir( dir ) # extract files for fn in zf.namelist(): fdir = os.path.dirname(fn) if fdir and not os.path.exists(fdir): os.makedirs(fdir) if fn.endswith('/'): continue try: out = open( fn, 'wb' ) buffer = StringIO( zf.read( fn )) buflen = 2 ** 20 datum = buffer.read( buflen ) while datum: out.write( datum ) datum = buffer.read( buflen ) out.close() finally: pass #print fn os.chdir( pushd )
def store_item(key, val, stream): """ The MANIFEST specification limits the width of individual lines to 72 bytes (including the terminating newlines). Any key and value pair that would be longer must be split up over multiple continuing lines""" key = key or "" val = val or "" if not (0 < len(key) < 69): raise Exception("Invalid key length: %i" % len(key)) if len(key) + len(val) > 68: kvbuffer = StringIO(": ".join((key, val))) # first grab 70 (which is 72 after the trailing newline) stream.write(kvbuffer.read(70)) # now only 69 at a time, because we need a leading space and a # trailing \n part = kvbuffer.read(69) while part: stream.write("\n ") stream.write(part) part = kvbuffer.read(69) kvbuffer.close() else: stream.write(key) stream.write(": ") stream.write(val) stream.write("\n")
class TBufferedTransport(TTransportBase,CReadableTransport): """Class that wraps another transport and buffers its I/O. The implementation uses a (configurable) fixed-size read buffer but buffers all writes until a flush is performed. """ DEFAULT_BUFFER = 4096 def __init__(self, trans, rbuf_size = DEFAULT_BUFFER): self.__trans = trans self.__wbuf = StringIO() self.__rbuf = StringIO("") self.__rbuf_size = rbuf_size def isOpen(self): return self.__trans.isOpen() def open(self): return self.__trans.open() def close(self): return self.__trans.close() def read(self, sz): ret = self.__rbuf.read(sz) if len(ret) != 0: return ret self.__rbuf = StringIO(self.__trans.read(max(sz, self.__rbuf_size))) return self.__rbuf.read(sz) def write(self, buf): self.__wbuf.write(buf) def flush(self): out = self.__wbuf.getvalue() # reset wbuf before write/flush to preserve state on underlying failure self.__wbuf = StringIO() self.__trans.write(out) self.__trans.flush() # Implement the CReadableTransport interface. @property def cstringio_buf(self): return self.__rbuf def cstringio_refill(self, partialread, reqlen): retstring = partialread if reqlen < self.__rbuf_size: # try to make a read of as much as we can. retstring += self.__trans.read(self.__rbuf_size) # but make sure we do read reqlen bytes. if len(retstring) < reqlen: retstring += self.__trans.readAll(reqlen - len(retstring)) self.__rbuf = StringIO(retstring) return self.__rbuf
def extract(self, filename, dir): zf = zipfile.ZipFile( filename ) namelist = zf.namelist() dirlist = filter( lambda x: x.endswith( '/' ), namelist ) filelist = filter( lambda x: not x.endswith( '/' ), namelist ) # make base pushd = os.getcwd() if not os.path.isdir( dir ): os.mkdir( dir ) os.chdir( dir ) # create directory structure dirlist.sort() for dirs in dirlist: dirs = dirs.split( '/' ) prefix = '' for dir in dirs: dirname = os.path.join( prefix, dir ) if dir and not os.path.isdir( dirname ): os.mkdir( dirname ) prefix = dirname # extract files for fn in filelist: try: out = open( fn, 'wb' ) buffer = StringIO( zf.read( fn )) buflen = 2 ** 20 datum = buffer.read( buflen ) while datum: out.write( datum ) datum = buffer.read( buflen ) out.close() finally: print fn os.chdir( pushd )
def deploy_project(args): conn = _get_zerocloud_conn(args) conn.authenticate() ui_auth_version = conn.auth_version # We can now reset the auth for the web UI, if needed if args.no_ui_auth: ui_auth_version = '0.0' auth = _prepare_auth(ui_auth_version, args, conn) auth_opts = jinja2.Markup(json.dumps(auth)) deploy_index = _deploy_zapp(conn, args.target, args.zapp, auth_opts, force=args.force) print('app deployed to\n %s/%s' % (conn.url, deploy_index)) if args.execute: # for compatibility with the option name in 'zpm execute' args.container = args.target resp_body_buffer = BytesIO() resp = execute(args, response_body_buffer=resp_body_buffer) resp_body_buffer.seek(0) if resp['status'] < 200 or resp['status'] >= 300: raise zpmlib.ZPMException(resp_body_buffer.read()) if args.summary: total_time, exec_table = _get_exec_table(resp) print('Execution summary:') print(exec_table) print('Total time: %s' % total_time) sys.stdout.write(resp_body_buffer.read())
def info(self): ''' Return a string describing the loaded database version. @returns English text string, or None if database is ancient. ''' fp = StringIO(self.cache) fp.seek(-3, os.SEEK_END) hasStructureInfo = False # first get past the database structure information for i in range(STRUCTURE_INFO_MAX_SIZE): if fp.read(3) == '\xFF\xFF\xFF': hasStructureInfo = True break fp.seek(-4, os.SEEK_CUR) if hasStructureInfo: fp.seek(-6, os.SEEK_CUR) else: # no structure info, must be pre Sep 2002 database, go back to end. fp.seek(-3, os.SEEK_END) for i in range(DATABASE_INFO_MAX_SIZE): if fp.read(3) == '\0\0\0': return fp.read(i) fp.seek(-4, os.SEEK_CUR)
def _open(self): header = StringIO(self.fp.read(24)) magic = header.read(4) if magic != "FTEX": raise ValueError("not a FTEX file") version = unpack("i", header.read(4)) self.size = unpack("ii", header.read(8)) linesize = (self.size[0] + 3) / 4 * 8 mipmap_count, format_count = unpack("ii", header.read(8)) self.mode = "RGB" self.tile = [] for i in range(format_count): format, where = unpack("ii", self.fp.read(8)) if format == 0: data = [] self.fp.seek(where) size, = unpack("i", self.fp.read(4)) for yb in xrange((self.size[1] + 3) / 4): decoded = dxtc.decodeDXT1(self.fp.read(linesize)) for d in decoded: data.append(d) data = "".join(data[:self.size[1]]) self.im = Image.core.new(self.mode, self.size) return self.fromstring(data) elif format == 1: # Uncompressed RGB self.tile.append(("raw", (0, 0) + self.size, where+4, (self.mode, 0, 1))) else: raise ValueError("Invalid texture format (expected 0 or 1, got %i)" % (format))
def write_AttenData_to_redis(self,OriAttenData,TagNum,SerialID): try: redispool = redis.ConnectionPool(host=self.redataIP,port=self.redataPort,db=self.redataDB) redata = redis.Redis(connection_pool=redispool) redpipe = redata.pipeline() OriAttenDataBuf = StringIO(OriAttenData) while TagNum != 0: # Obtain Tag Serial ID # Serial Number Has Two Ways Of Express # (1) String 24 , Ascii Code OriTagSerialID = OriAttenDataBuf.read(12) TagSerialID = binascii.b2a_hex(OriTagSerialID) # (2) String 8 , Decimal System # OriAttenDataBuf.read(8) # OriTagSerialID = OriAttenDataBuf.read(4) # TagSerialID = struct.unpack('<i', OriTagSerialID)[0] # Obtain Atten Stamp Time OriTimeStamp = OriAttenDataBuf.read(4) TimeStamp = struct.unpack('<i', OriTimeStamp)[0] redpipe.rpush("OriAttenDataList","%s-%s-%s"%(SerialID,TimeStamp,TagSerialID)) self.logger.debug("%s - %s - %s - %s"%(TagNum,TimeStamp,time.ctime(TimeStamp),TagSerialID)) TagNum = TagNum - 1 redpipe.execute() except Exception,e: self.logger.error("Write Atten Data To Redis Exception,Error is %s,But Main Program Not Quit......"%e)
def from_data(self, fields, rows): fp = StringIO() writer = csv.writer(fp, quoting=csv.QUOTE_ALL) writer.writerow([name.encode("utf-8") for name in fields]) for data in rows: row = [] for d in data: if isinstance(d, basestring): d = d.replace("\n", " ").replace("\t", " ") try: d = d.encode("utf-8") except UnicodeError: pass if d is False: d = None row.append(d) writer.writerow(row) if fp.tell() >= 1250: fp.seek(0) data = fp.read() yield data fp.seek(0) fp.truncate() row = [] fp.seek(0) # Flush the final data data = fp.read() fp.close() yield data return
def read(self, path): self._path = path with open(path) as fh: log.debug("Reading %r of size %d bytes.", path, os.path.getsize(path)) data = StringIO(fh.read()) self._header = Header.decode(data) self._text = data.read(self._header.text) self._data = data.read(self._header.data) text_reloc = data.read(self._header.trsize) data_reloc = data.read(self._header.drsize) symbols = data.read(self._header.syms) str_size = struct.unpack(">I", data.read(4))[0] strings = data.read() if str_size != len(strings): log.warn("Wrong size of string table!") self._strings = StringTable.decode(strings) for i in range(0, len(symbols), 12): self._symbols.append(SymbolInfo.decode(symbols[i : i + 12])) for i in range(0, len(text_reloc), 8): self._text_relocs.append(RelocInfo.decode(text_reloc[i : i + 8])) for i in range(0, len(data_reloc), 8): self._data_relocs.append(RelocInfo.decode(data_reloc[i : i + 8]))
def rgb_merge(self, r, g, b): """ (Re)combine the red, green and blue color channels from three separate pictures of identical size into one. """ if self.empty != True: warn("Running rgb_merge() on a non-empty BMP; the existing data will be overwritten!") # Ugh... if len(set((r.width, g.width, b.width))) != 1 or len(set((r.height, g.height, b.height))) != 1 or len(set((r.bpp, g.bpp, b.bpp))) != 1: die("The dimensions and/or bpp differs between the input images to rgb_merge()!") rf = StringIO(r.bitmap_data) gf = StringIO(g.bitmap_data) bf = StringIO(b.bitmap_data) out_bitmap_data = "" for row_num in xrange(0, b.height): for pix in xrange(0, b.width): red_pixel = struct.unpack("3B", rf.read(3))[2] green_pixel = struct.unpack("3B", gf.read(3))[1] blue_pixel = struct.unpack("3B", bf.read(3))[0] out_bitmap_data += "".join( (chr(blue_pixel), chr(green_pixel), chr(red_pixel)) ) out_bitmap_data += chr(0x00) * r.padding_size rf.seek(r.padding_size, 1) gf.seek(g.padding_size, 1) bf.seek(b.padding_size, 1) return BMP(r.all_headers + out_bitmap_data, True)
def start_drag_operation(self, event): '''Start dragging whatever is selected''' fd = StringIO() modules_to_save = [m.module_num for m in self.get_selected_modules()] self.__pipeline.savetxt(fd, modules_to_save) pipeline_data_object = PipelineDataObject() fd.seek(0) pipeline_data_object.SetData(fd.read()) text_data_object = wx.TextDataObject() fd.seek(0) text_data_object.SetData(fd.read()) data_object = wx.DataObjectComposite() data_object.Add(pipeline_data_object) data_object.Add(text_data_object) drop_source = wx.DropSource(self.list_ctrl) drop_source.SetData(data_object) self.drag_underway = True self.drag_start = event.Position self.drag_time = time.time() selected_module_ids = [m.id for m in self.get_selected_modules()] self.__pipeline.start_undoable_action() try: result = drop_source.DoDragDrop(wx.Drag_AllowMove) self.drag_underway = False if result == wx.DragMove: for id in selected_module_ids: for module in self.__pipeline.modules(): if module.id == id: self.__pipeline.remove_module(module.module_num) break finally: self.__pipeline.stop_undoable_action("Drag and drop")
def save(self, *args, **kwargs): image = PILImage.open(self.instance.image.file) temp_handle = StringIO() greyscale_image = image.convert("L") greyscale_image.save(temp_handle, 'png') temp_handle.seek(0) suf = SimpleUploadedFile(path.split(self.instance.image.name)[-1], temp_handle.read(), content_type='image/png') name = suf.name if "." in name: name = name.split(".")[0] self.instance.preprocessed_image.save("%s_l.png" % name, suf, save=False) if self.cleaned_data["process"] == PROCESSES_DICT["HANDWRITTEN"]: factor = [5, 2, 0.25] temp_handle = StringIO() raw_mask = extract_handwritten_text(image, factor=factor) regions_mask = draw_regions(raw_mask, raw_mask, outline=["white", "white", None], fill=["white", "white", None]) handwritten_mask = remove_noise(regions_mask).convert("1") handwritten_mask.save(temp_handle, 'png') temp_handle.seek(0) suf = SimpleUploadedFile(path.split(self.instance.image.name)[-1], temp_handle.read(), content_type='image/png') name = suf.name if "." in name: name = name.split(".")[0] self.instance.handwritten_mask.save("%s_h.png" % name, suf, save=False) return super(InitialImageForm, self).save(*args, **kwargs)
class TFramedTransport(TTransportBase, CReadableTransport): """Class that wraps another transport and frames its I/O when writing.""" def __init__(self, trans,): self.__trans = trans self.__rbuf = StringIO() self.__wbuf = StringIO() def isOpen(self): return self.__trans.isOpen() def open(self): return self.__trans.open() def close(self): return self.__trans.close() def read(self, sz): ret = self.__rbuf.read(sz) if len(ret) != 0: return ret self.readFrame() return self.__rbuf.read(sz) def readFrame(self): buff = self.__trans.readAll(4) sz, = unpack('!i', buff) self.__rbuf = StringIO(self.__trans.readAll(sz)) def write(self, buf): self.__wbuf.write(buf) def flush(self): wout = self.__wbuf.getvalue() wsz = len(wout) # reset wbuf before write/flush to preserve state on underlying failure self.__wbuf = StringIO() # N.B.: Doing this string concatenation is WAY cheaper than making # two separate calls to the underlying socket object. Socket writes in # Python turn out to be REALLY expensive, but it seems to do a pretty # good job of managing string buffer operations without excessive copies buf = pack("!i", wsz) + wout self.__trans.write(buf) self.__trans.flush() # Implement the CReadableTransport interface. @property def cstringio_buf(self): return self.__rbuf def cstringio_refill(self, prefix, reqlen): # self.__rbuf will already be empty here because fastbinary doesn't # ask for a refill until the previous buffer is empty. Therefore, # we can start reading new frames immediately. while len(prefix) < reqlen: self.readFrame() prefix += self.__rbuf.getvalue() self.__rbuf = StringIO(prefix) return self.__rbuf
def extractPIL(quad): fop = StringIO(quad['source'].get()) strmarker=fop.read(4) marker=unpack('<4B',strmarker) if strmarker in ('KCDC','KCD2'): raise CompressedError,'Section is compressed' if marker not in ((1,0,3,3),(1,0,5,5)): raise LoadError('Bad marker: %s' % (marker,)) junk,x,y,w,h,filesize=unpack('<6l',fop.read(24)) w-=x h-=y linelengths=unpack('<%iH' % (h),fop.read(2*h)) surf = Image.new('P', (w,h)) surf.putpalette(PALETTE) for line in range(h): if linelengths[line]!=0: linepos=0 xpos=0 while linepos<linelengths[line]: skip,linesize=unpack('<2B',fop.read(2)) xpos+=skip linepos+=2 lineimage = Image.frombytes('P',(linesize,1),fop.read(linesize)) surf.paste(lineimage, (xpos,line)) linepos+=linesize return surf
def decrypt(buf, passphrase): '''Decrypt *buf''' fh = StringIO(buf) len_ = struct.unpack(b'<B', fh.read(struct.calcsize(b'<B')))[0] nonce = fh.read(len_) key = sha256(passphrase + nonce) cipher = aes.AES(key) #IGNORE:E1102 hmac_ = hmac.new(key, digestmod=hashlib.sha256) # Read (encrypted) hmac hash_ = fh.read(HMAC_SIZE) buf = fh.read() buf = cipher.process(buf) hmac_.update(buf) hash_ = cipher.process(hash_) if hash_ != hmac_.digest(): raise ChecksumError('HMAC mismatch') return buf
def tokenize(query): if isinstance(query, basestring): query = StringIO(query) quoted = None sdata = [] while True: c = query.read(1) if not c: break if quoted: if c == quoted: yield TOKEN_STRING, ''.join(sdata) sdata = [] quoted = None else: if c == '\\': c = query.read(1) if not c: break sdata.append(c) continue if c in SYMBOLS_QUOTE: quoted = c continue for sym_token, sym in TOKEN_SYMBOLS_TABLE.iteritems(): if c in sym: stoken = _sdata_to_token(sdata) sdata = [] if stoken is not None: yield stoken if sym_token is not None: yield sym_token, c break else: if c in '><=!': stoken = _sdata_to_token(sdata) sdata = [] if stoken is not None: yield stoken nc = query.read(1) if not c:break if nc == '=': yield TOKEN_OPERATOR, c + nc elif (c == '<' and nc in '<') or (c == '>' and nc == '>'): yield TOKEN_OPERATOR, c + nc else: if c in '=!': c += '=' yield TOKEN_OPERATOR, c if nc not in SYMBOLS_SPACE: sdata.append(nc) else: sdata.append(c) if quoted: raise Exception("Missing end quote") stoken = _sdata_to_token(sdata) if stoken is not None: yield stoken
class UserEnvFile(object): """ Behaves like a file object, but instead of being directly mapped to a file it writes to that file from inside of a UserEnv. """ def __init__(self, userenv, filename): self.stringio = StringIO() self.userenv = userenv self.filename = filename def read(self, *args, **kwargs): self.stringio.read(*args, **kwargs) def readlines(self, *args, **kwargs): self.stringio.readlines(*args, **kwargs) def write(self, *args, **kwargs): self.stringio.write(*args, **kwargs) def writelines(self, *args, **kwargs): self.stringio.writelines(*args, **kwargs) def seek(self, *args, **kwargs): self.stringio.seek(*args, **kwargs) def close(self): self.userenv.write_string_to_file(self.stringio.getvalue(), self.filename) self.userenv = None self.stringio.close()
def generate_card(IMG_FILE,IMG_URL,TEXT_FRONT,TEXT_INSIDE): """Main function to generate PDF and print to stdout. Designed to be run as a CGI application.""" if not (IMG_FILE or IMG_URL): print 'You must upload an image file or provide a URL to one' return tmp = StringIO() #Canvas Setup c = canvas.Canvas(tmp, pagesize=letter, pageCompression=0) #If output size is important set pageCompression=1, but remember that, compressed documents #will be smaller, but slower to generate. Note that images are always compressed, and this option will only #save space if you have a very large amount of text and vector graphics on each page. #Do I need 'MacRomanEncoding' for Macs? #Note: 0,0 coordinate in canvas is bottom left. c.setAuthor('Utility Mill - utilitymill.com/utility/greeting_card_generator') c.setTitle('Beautiful, expensive greeting card created at utilitymill.com') #add_fold_lines(c) #early feedback says lines aren't necessary. Uncomment here to put them in put_in_front_picture(c,IMG_FILE,IMG_URL) write_text(c,TEXT_FRONT.replace('\r',''),TEXT_INSIDE.replace('\r','')) #The showPage method saves the current page of the canvas c.showPage() #The save method stores the file and closes the canvas. c.save() tmp.seek(0) print 'Content-Type: application/pdf' print tmp.read()
def decrypt_block_pw(password, crypted_data, compress='zlib', compress_options=[]): """ Decrypts a file using AES (CBC mode) with the given arbitrary password. compress_options: passed to the decompression ficntion you chose via '*compress_options'. even though it is decompression we do here we call the parameter the same as in encrypt_block_pw() for symmetry. sorry. """ ################## # prepare key = getHashKey(password) # make 32byte key for AES assert len(crypted_data) > 0 infile = StringIO(crypted_data) ################## # aux stuff # - get original compressed size origsize = struct.unpack('<Q', infile.read(struct.calcsize('Q')))[0] iv = infile.read(16) ################## # decrypt decryptor = AES.new(key, AES.MODE_CBC, iv) data = decryptor.decrypt(infile.read()) ################## # decompress if compress == None: rawdata = data[:origsize] elif compress == 'zlib': # level=1 is very fast, and good enough to get rid of long repeats rawdata = zlib.decompress(data[:origsize], *compress_options) else: raise ValueError("unknown decompression '%s'" % compression) # result return rawdata
def get_brickname(dev): counterout = random.randint(1, 200) sout = StringIO() sout.write(struct.pack('<H', counterout)) sout.write(struct.pack('B', DIRECT_COMMAND_REPLY)) sout.write(struct.pack('B', 0x06)) # 00001100 two variables: see lms2012/lms2012/doc/html/directcommands.html sout.write(struct.pack('B', 0x00)) # 00000000 sout.write(struct.pack('B', 0xD3)) # opCOM_GET sout.write(struct.pack('B', 13)) # GET_BRICKNAME sout.write(struct.pack('B', 0x06)) # LC0(6) Local Constant sout.write(struct.pack('B', 0x60)) # GV0(0) Global Variable for response message = sout.getvalue() write_message(dev, message) ret = dev.read(EP_IN, 1024, 0, 100) sin = StringIO(ret) cmd_size = struct.unpack('<H', sin.read(2)) counterin = struct.unpack('<H', sin.read(2)) cmd_type = struct.unpack('B', sin.read(1)) brickname = [] value = sin.read(1) while value != '\x00': brickname.append(value) value = sin.read(1) return ''.join(brickname)
class Response(object): def __init__(self, http_response, spool_size=MAX_MEM_FILE_SIZE): # We have to read the full response, even if we don't expect a body, # otherwise, the next request fails. The user may choose to do this, # use the automatic disc/memory buffering. chunk_size = max(spool_size, MAX_MEM_FILE_SIZE) // 2 self.http_response = http_response if spool_size > 0: # automatic disc/mem buffering of response if http_response.getheader('Content-Length') > spool_size: self.body = tempfile.TemporaryFile(bufsize=chunk_size) else: self.body = StringIO() while True: chunk = http_response.read(chunk_size) if not chunk: break self.body.write(chunk) self.body.seek(0) else: self.body = http_response if http_response.status >= 300: # read the error message into a StringIO (it should be small) if (spool_size <= 0 or http_response.getheader('Content-Length') > spool_size): self.body = StringIO(self.body.read()) self.message = self.body.read() self.body.seek(0) else: self.message = "%03d %s" % (http_response.status, http_response.reason)
def deserialize_msg(self, data): msg = {} data_len = len(data) if data_len < HEADER_LEN: raise HeaderTooShortError("got {} of {} bytes".format( data_len, HEADER_LEN)) data = StringIO(data) header = data.read(HEADER_LEN) msg.update(self.deserialize_header(header)) if (data_len - HEADER_LEN) < msg['length']: self.required_len = HEADER_LEN + msg['length'] raise PayloadTooShortError("got {} of {} bytes".format( data_len, HEADER_LEN + msg['length'])) payload = data.read(msg['length']) computed_checksum = sha256(sha256(payload))[:4] if computed_checksum != msg['checksum']: raise InvalidPayloadChecksum("{} != {}".format( binascii.hexlify(computed_checksum), binascii.hexlify(msg['checksum']))) if msg['command'] == "version": msg.update(self.deserialize_version_payload(payload)) elif msg['command'] == "addr": msg.update(self.deserialize_addr_payload(payload)) elif msg['command'] == "inv": msg.update(self.deserialize_inv_payload(payload)) return (msg, data.read())
def add_packet(self, new_packet): """ Adds the packet to the unfinished object. Updates all things appropriately :param string newPacket: The incoming packet """ packet = unpack(new_packet) reader = StringIO(packet[1]) # Get the actual packet data as a StringIO packet_number = _bin_unpack(reader.read(4)) # Read the 4-byte number of the packet # Try to write the info to the correct place self.info_buffer.seek(_UnfinishedPacket.MAX_PACKET_SIZE * packet_number) self.info_buffer.write(reader.read()) reader.close() self.info_buffer.seek(0) # Update incoming packet tracking data if(packet_number > self.last_received): self.last_received = packet_number for num in range(self.last_received,packet_number): self.missing_packets.append(num) else: self.missing_packets.remove(packet_number) # See if all packets are received. if(self.last_received == self.num_packets-1 and not self.missing_packets): self.done = True
def _excel_data_getter_for_xlwt(name, excel_data, sheet2name=None, sheet2data=None): """ 在本地生成excel临时文件, 返回路径待上传 sheet2name & sheet2data 用来记录报表查询的条件 """ workbook = xlwt.Workbook(encoding='utf-8') worksheet = workbook.add_sheet(name) # header style header_style = xlwt.easyxf( 'pattern: pattern solid;font: name Source Han Sans CN;') header_font = xlwt.Font() header_font.name = u'Source Han Sans CN' # 指定“Source Han Sans CN” header_font.height = 200 header_style.font = header_font borders = xlwt.Borders() borders.bottom = xlwt.Borders.THIN header_style.borders = borders header_style.pattern.pattern_fore_colour = 0x16 # normal style normal_style = xlwt.XFStyle() normal_font = xlwt.Font() normal_font.name = u'Source Han Sans CN' # 指定“Source Han Sans CN” normal_font.height = 200 normal_style.font = normal_font # group style group_style = xlwt.XFStyle() # xlwt.easyxf('pattern: pattern solid;') group_font = xlwt.Font() group_font.name = u'Source Han Sans CN' # 指定“Source Han Sans CN” group_font.height = 200 # 字体大小 # group_font.colour_index = 0x0C # group_font.bold = True # group_font.italic = True group_style.font = group_font # group_style.pattern.pattern_fore_colour = 0x16 borders = xlwt.Borders() borders.bottom = xlwt.Borders.THIN group_style.borders = borders # 对于group的行,将前面空白的列不应用group样式 for r in range(len(excel_data)): # row style = normal_style flag = 'normal' # normal, group_no_start, group_start if r >= 1: flag = 'group_no_start' elif r == 0: style = header_style for c in range(len(excel_data[r])): # column if flag == 'group_no_start': if excel_data[r][c] is not None: flag = 'group_start' style = group_style if excel_data[r][c] is None: worksheet.write(r, c, None, style) elif isinstance(excel_data[r][c], (int, long, float, complex)): worksheet.write(r, c, excel_data[r][c], style) else: worksheet.write(r, c, '%s' % excel_data[r][c], style) if sheet2name and sheet2data: # sheet2 添加, 此处是为了在excel里面添加查询时候的条件 worksheet2 = workbook.add_sheet(sheet2name) for r in range(len(sheet2data)): # row style = normal_style flag = 'normal' # normal, group_no_start, group_start if r >= 1: flag = 'group_no_start' elif r == 0: style = header_style for c in range(len(sheet2data[r])): # column if flag == 'group_no_start': if sheet2data[r][c] is not None: flag = 'group_start' style = group_style if sheet2data[r][c] is None: worksheet2.write(r, c, None, style) elif isinstance(sheet2data[r][c], (int, long, float, complex)): worksheet2.write(r, c, sheet2data[r][c], style) else: worksheet2.write(r, c, '%s' % sheet2data[r][c], style) fp = StringIO() workbook.save(fp) fp.seek(0) data = fp.read() fp.close() return data
def load_course(self, course_dir, tracker): """ Load a course into this module store course_path: Course directory name returns a CourseDescriptor for the course """ log.debug( '========> Starting course import from {0}'.format(course_dir)) with open(self.data_dir / course_dir / "course.xml") as course_file: # VS[compat] # TODO (cpennington): Remove this once all fall 2012 courses have # been imported into the cms from xml course_file = StringIO( clean_out_mako_templating(course_file.read())) course_data = etree.parse(course_file, parser=edx_xml_parser).getroot() org = course_data.get('org') if org is None: msg = ("No 'org' attribute set for course in {dir}. " "Using default 'edx'".format(dir=course_dir)) log.warning(msg) tracker(msg) org = 'edx' course = course_data.get('course') if course is None: msg = ("No 'course' attribute set for course in {dir}." " Using default '{default}'".format(dir=course_dir, default=course_dir)) log.warning(msg) tracker(msg) course = course_dir url_name = course_data.get('url_name', course_data.get('slug')) policy_dir = None if url_name: policy_dir = self.data_dir / course_dir / 'policies' / url_name policy_path = policy_dir / 'policy.json' policy = self.load_policy(policy_path, tracker) # VS[compat]: remove once courses use the policy dirs. if policy == {}: old_policy_path = self.data_dir / course_dir / 'policies' / '{0}.json'.format( url_name) policy = self.load_policy(old_policy_path, tracker) else: policy = {} # VS[compat] : 'name' is deprecated, but support it for now... if course_data.get('name'): url_name = Location.clean(course_data.get('name')) tracker("'name' is deprecated for module xml. Please use " "display_name and url_name.") else: raise ValueError( "Can't load a course without a 'url_name' " "(or 'name') set. Set url_name.") course_id = CourseDescriptor.make_id(org, course, url_name) system = ImportSystem( self, course_id, course_dir, policy, tracker, self.parent_trackers[course_id], self.load_error_modules, ) course_descriptor = system.process_xml( etree.tostring(course_data, encoding='unicode')) # If we fail to load the course, then skip the rest of the loading steps if isinstance(course_descriptor, ErrorDescriptor): return course_descriptor # NOTE: The descriptors end up loading somewhat bottom up, which # breaks metadata inheritance via get_children(). Instead # (actually, in addition to, for now), we do a final inheritance pass # after we have the course descriptor. compute_inherited_metadata(course_descriptor) # now import all pieces of course_info which is expected to be stored # in <content_dir>/info or <content_dir>/info/<url_name> self.load_extra_content(system, course_descriptor, 'course_info', self.data_dir / course_dir / 'info', course_dir, url_name) # now import all static tabs which are expected to be stored in # in <content_dir>/tabs or <content_dir>/tabs/<url_name> self.load_extra_content(system, course_descriptor, 'static_tab', self.data_dir / course_dir / 'tabs', course_dir, url_name) self.load_extra_content(system, course_descriptor, 'custom_tag_template', self.data_dir / course_dir / 'custom_tags', course_dir, url_name) self.load_extra_content(system, course_descriptor, 'about', self.data_dir / course_dir / 'about', course_dir, url_name) log.debug('========> Done with course import from {0}'.format( course_dir)) return course_descriptor
class GenericExprVisitor(object): """ A DWARF expression is a sequence of instructions encoded in a block of bytes. This class decodes the sequence into discrete instructions with their arguments and allows generic "visiting" to process them. Usage: subclass this class, and override the needed methods. The easiest way would be to just override _after_visit, which gets passed each decoded instruction (with its arguments) in order. Clients of the visitor then just execute process_expr. The subclass can keep its own internal information updated in _after_visit and provide methods to extract it. For a good example of this usage, see the ExprDumper class in the descriptions module. A more complex usage could be to override visiting methods for specific instructions, by placing them into the dispatch table. """ def __init__(self, structs): self.structs = structs self._init_dispatch_table() self.stream = None self._cur_opcode = None self._cur_opcode_name = None self._cur_args = [] def process_expr(self, expr): """ Process (visit) a DWARF expression. expr should be a list of (integer) byte values. """ self.stream = StringIO(bytelist2string(expr)) while True: # Get the next opcode from the stream. If nothing is left in the # stream, we're done. byte = self.stream.read(1) if len(byte) == 0: break # Decode the opcode and its name self._cur_opcode = ord(byte) self._cur_opcode_name = DW_OP_opcode2name.get( self._cur_opcode, 'OP:0x%x' % self._cur_opcode) # Will be filled in by visitors self._cur_args = [] # Dispatch to a visitor function visitor = self._dispatch_table.get( self._cur_opcode, self._default_visitor) visitor(self._cur_opcode, self._cur_opcode_name) # Finally call the post-visit function self._after_visit( self._cur_opcode, self._cur_opcode_name, self._cur_args) def _after_visit(self, opcode, opcode_name, args): pass def _default_visitor(self, opcode, opcode_name): pass def _visit_OP_with_no_args(self, opcode, opcode_name): self._cur_args = [] def _visit_OP_addr(self, opcode, opcode_name): self._cur_args = [ struct_parse(self.structs.Dwarf_target_addr(''), self.stream)] def _make_visitor_arg_struct(self, struct_arg): """ Create a visitor method for an opcode that that accepts a single argument, specified by a struct. """ def visitor(opcode, opcode_name): self._cur_args = [struct_parse(struct_arg, self.stream)] return visitor def _make_visitor_arg_struct2(self, struct_arg1, struct_arg2): """ Create a visitor method for an opcode that that accepts two arguments, specified by structs. """ def visitor(opcode, opcode_name): self._cur_args = [ struct_parse(struct_arg1, self.stream), struct_parse(struct_arg2, self.stream)] return visitor def _init_dispatch_table(self): self._dispatch_table = {} def add(opcode_name, func): self._dispatch_table[DW_OP_name2opcode[opcode_name]] = func add('DW_OP_addr', self._visit_OP_addr) add('DW_OP_const1u', self._make_visitor_arg_struct(self.structs.Dwarf_uint8(''))) add('DW_OP_const1s', self._make_visitor_arg_struct(self.structs.Dwarf_int8(''))) add('DW_OP_const2u', self._make_visitor_arg_struct(self.structs.Dwarf_uint16(''))) add('DW_OP_const2s', self._make_visitor_arg_struct(self.structs.Dwarf_int16(''))) add('DW_OP_const4u', self._make_visitor_arg_struct(self.structs.Dwarf_uint32(''))) add('DW_OP_const4s', self._make_visitor_arg_struct(self.structs.Dwarf_int32(''))) add('DW_OP_const8u', self._make_visitor_arg_struct2( self.structs.Dwarf_uint32(''), self.structs.Dwarf_uint32(''))) add('DW_OP_const8s', self._make_visitor_arg_struct2( self.structs.Dwarf_int32(''), self.structs.Dwarf_int32(''))) add('DW_OP_constu', self._make_visitor_arg_struct(self.structs.Dwarf_uleb128(''))) add('DW_OP_consts', self._make_visitor_arg_struct(self.structs.Dwarf_sleb128(''))) add('DW_OP_pick', self._make_visitor_arg_struct(self.structs.Dwarf_uint8(''))) add('DW_OP_plus_uconst', self._make_visitor_arg_struct(self.structs.Dwarf_uleb128(''))) add('DW_OP_bra', self._make_visitor_arg_struct(self.structs.Dwarf_int16(''))) add('DW_OP_skip', self._make_visitor_arg_struct(self.structs.Dwarf_int16(''))) for opname in [ 'DW_OP_deref', 'DW_OP_dup', 'DW_OP_drop', 'DW_OP_over', 'DW_OP_swap', 'DW_OP_swap', 'DW_OP_rot', 'DW_OP_xderef', 'DW_OP_abs', 'DW_OP_and', 'DW_OP_div', 'DW_OP_minus', 'DW_OP_mod', 'DW_OP_mul', 'DW_OP_neg', 'DW_OP_not', 'DW_OP_plus', 'DW_OP_shl', 'DW_OP_shr', 'DW_OP_shra', 'DW_OP_xor', 'DW_OP_eq', 'DW_OP_ge', 'DW_OP_gt', 'DW_OP_le', 'DW_OP_lt', 'DW_OP_ne', 'DW_OP_nop', 'DW_OP_push_object_address', 'DW_OP_form_tls_address', 'DW_OP_call_frame_cfa']: add(opname, self._visit_OP_with_no_args) for n in range(0, 32): add('DW_OP_lit%s' % n, self._visit_OP_with_no_args) add('DW_OP_reg%s' % n, self._visit_OP_with_no_args) add('DW_OP_breg%s' % n, self._make_visitor_arg_struct(self.structs.Dwarf_sleb128(''))) add('DW_OP_fbreg', self._make_visitor_arg_struct(self.structs.Dwarf_sleb128(''))) add('DW_OP_regx', self._make_visitor_arg_struct(self.structs.Dwarf_uleb128(''))) add('DW_OP_bregx', self._make_visitor_arg_struct2( self.structs.Dwarf_uleb128(''), self.structs.Dwarf_sleb128(''))) add('DW_OP_piece', self._make_visitor_arg_struct(self.structs.Dwarf_uleb128(''))) add('DW_OP_bit_piece', self._make_visitor_arg_struct2( self.structs.Dwarf_uleb128(''), self.structs.Dwarf_uleb128(''))) add('DW_OP_deref_size', self._make_visitor_arg_struct(self.structs.Dwarf_int8(''))) add('DW_OP_xderef_size', self._make_visitor_arg_struct(self.structs.Dwarf_int8(''))) add('DW_OP_call2', self._make_visitor_arg_struct(self.structs.Dwarf_uint16(''))) add('DW_OP_call4', self._make_visitor_arg_struct(self.structs.Dwarf_uint32(''))) add('DW_OP_call_ref', self._make_visitor_arg_struct(self.structs.Dwarf_offset('')))
def readDSF(path, netdefs, terrains, bbox=None, bytype=None): wantoverlay = not terrains wantmesh = not wantoverlay baddsf=(0, "Invalid DSF file", path) if __debug__: print path.encode(getfilesystemencoding() or 'utf-8') h=file(path, 'rb') sig=h.read(8) if sig.startswith('7z\xBC\xAF\x27\x1C'): # X-Plane 10 compressed if __debug__: clock=time.clock() if Archive7z: h.seek(0) data=Archive7z(h).getmember(basename(path)).read() h.close() h=StringIO(data) else: h.close() cmds=exists('/usr/bin/7zr') and '/usr/bin/7zr' or '/usr/bin/7za' cmds='%s e "%s" -o"%s" -y' % (cmds, path, gettempdir()) (i,o,e)=popen3(cmds) i.close() err=o.read() err+=e.read() o.close() e.close() h=file(join(gettempdir(), basename(path)), 'rb') if __debug__: print "%6.3f time in decompression" % (time.clock()-clock) sig=h.read(8) if sig!='XPLNEDSF' or unpack('<I',h.read(4))!=(1,): raise IOError, baddsf # scan for contents table={} h.seek(-16,SEEK_END) # stop at MD5 checksum end=h.tell() p=12 while p<end: h.seek(p) d=h.read(8) (c,l)=unpack('<4sI', d) table[c]=p+4 p+=l if __debug__: print table if not 'DAEH' in table or not 'NFED' in table or not 'DOEG' in table or not 'SDMC' in table: raise IOError, baddsf # header h.seek(table['DAEH']) (l,)=unpack('<I', h.read(4)) headend=h.tell()+l-8 if h.read(4)!='PORP': raise IOError, baddsf (l,)=unpack('<I', h.read(4)) placements=[] nets = defaultdict(list) mesh = defaultdict(list) c=h.read(l-9).split('\0') h.read(1) overlay=0 for i in range(0, len(c)-1, 2): if c[i]=='sim/overlay': overlay=int(c[i+1]) elif c[i]=='sim/south': south=int(c[i+1]) elif c[i]=='sim/west': west=int(c[i+1]) elif c[i] in Exclude.NAMES: if ',' in c[i+1]: # Fix for FS2XPlane 0.99 v=[float(x) for x in c[i+1].split(',')] else: v=[float(x) for x in c[i+1].split('/')] placements.append(Exclude(Exclude.NAMES[c[i]], 0, [[Node([v[0],v[1]]), Node([v[2],v[1]]), Node([v[2],v[3]]), Node([v[0],v[3]])]])) if wantoverlay and not overlay and not bbox: # Not an Overlay DSF - bail early h.close() raise IOError (0, "%s is not an overlay." % basename(path)) if overlay and (bbox or wantmesh): # only interested in mesh data - bail early h.close() return (south, west, placements, nets, mesh) h.seek(headend) # Definitions Atom h.seek(table['NFED']) (l,)=unpack('<I', h.read(4)) defnend=h.tell()+l-8 terrain=objects=polygons=networks=rasternames=[] while h.tell()<defnend: c=h.read(4) (l,)=unpack('<I', h.read(4)) if l==8: pass # empty elif c=='TRET': terrain=h.read(l-9).replace('\\','/').replace(':','/').split('\0') h.read(1) elif c=='TJBO': objects=[x.decode() for x in h.read(l-9).replace('\\','/').replace(':','/').split('\0')] # X-Plane only supports ASCII h.read(1) elif c=='YLOP': polygons=[x.decode() for x in h.read(l-9).replace('\\','/').replace(':','/').split('\0')] # X-Plane only supports ASCII h.read(1) elif c=='WTEN': networks=h.read(l-9).replace('\\','/').replace(':','/').split('\0') h.read(1) elif c=='NMED': rasternames=h.read(l-9).replace('\\','/').replace(':','/').split('\0') h.read(1) else: h.seek(l-8, 1) # We only understand a limited set of v10-style networks if networks and networks!=[NetworkDef.DEFAULTFILE]: if wantoverlay and not bbox: raise IOError, (0, 'Unsupported network: %s' % ', '.join(networks)) else: skipnetworks = True else: skipnetworks = False # Geodata Atom if __debug__: clock=time.clock() # Processor time h.seek(table['DOEG']) (l,)=unpack('<I', h.read(4)) geodend=h.tell()+l-8 pool=[] scal=[] po32=[] sc32=[] while h.tell()<geodend: c=h.read(4) (l,)=unpack('<I', h.read(4)) if skipnetworks and c in ['23OP','23CS']: h.seek(l-8, 1) # Skip network data elif c in ['LOOP','23OP']: if c=='LOOP': poolkind=pool fmt='<H' ifmt=uint16 size=2 else: poolkind=po32 fmt='<I' ifmt=uint32 size=4 (n,p)=unpack('<IB', h.read(5)) #if __debug__: print c,n,p thispool = empty((n,p), ifmt) # Pool data is supplied in column order (by "plane"), so use numpy slicing to assign for i in range(p): (e,)=unpack('<B', h.read(1)) # encoding type - default DSFs use e=3 if e&2: # RLE offset = 0 while offset<n: (r,)=unpack('<B', h.read(1)) if (r&128): # repeat (d,)=unpack(fmt, h.read(size)) thispool[offset:offset+(r&127),i] = d offset += (r&127) else: # non-repeat thispool[offset:offset+r,i] = fromstring(h.read(r*size), fmt) offset += r else: # raw thispool[:,i] = fromstring(h.read(n*size), fmt) if e&1: # differenced thispool[:,i] = cumsum(thispool[:,i], dtype=ifmt) poolkind.append(thispool) elif c=='LACS': scal.append(fromstring(h.read(l-8), '<f').reshape(-1,2)) #if __debug__: print c,scal[-1] elif c=='23CS': sc32.append(fromstring(h.read(l-8), '<f').reshape(-1,2)) #if __debug__: print c,sc32[-1] else: h.seek(l-8, 1) if __debug__: print "%6.3f time in GEOD atom" % (time.clock()-clock) # Rescale pools if __debug__: clock=time.clock() # Processor time for i in range(len(pool)): # number of pools curpool = pool[i] curscale= scal[i] newpool = empty(curpool.shape, float) # need double precision for placements for plane in range(len(curscale)): # number of planes in this pool (scale,offset) = curscale[plane] if scale: newpool[:,plane] = curpool[:,plane] * (scale/0xffff) + float(offset) else: newpool[:,plane] = curpool[:,plane] + float(offset) # numpy doesn't work efficiently skipping around the variable sized pools, so don't consolidate pool[i] = newpool # if __debug__: # Dump pools # for p in pool: # for x in p: # for y in x: # print "%.5f" % y, # print # print # Rescale network pool while po32 and not len(po32[-1]): po32.pop() # v10 DSFs have a bogus zero-dimensioned pool at the end if po32: if len(po32)!=1 or sc32[0].shape!=(4,2): raise IOError, baddsf # code below is optimized for one big pool if wantoverlay: newpool = empty((len(po32[0]),3), float) # Drop junction IDs. Need double precision for placements for plane in range(3): (scale,offset) = sc32[0][plane] newpool[:,plane] = po32[0][:,plane] * (scale/0xffffffffL) + float(offset) po32 = newpool else: # convert to local coords if we just want network lines. Do calculations in double, store result as single. centrelat = south+0.5 centrelon = west+0.5 newpool = empty((len(po32[0]),6), float32) # drop junction IDs, add space for color lat = po32[0][:,1] * (sc32[0][1][0]/0xffffffffL) + float(sc32[0][1][1]) # double newpool[:,0] =(po32[0][:,0] * onedeg*(sc32[0][0][0]/0xffffffffL) + onedeg*(sc32[0][0][1] - centrelon)) * numpy.cos(numpy.radians(lat)) # lon -> x newpool[:,1] = po32[0][:,2] * (sc32[0][2][0]/0xffffffffL) + float(sc32[0][2][1]) # y newpool[:,2] = onedeg*centrelat - onedeg*lat # lat -> z if __debug__: assert not sc32[0][3].any() # Junction IDs are unscaled newpool[:,3] = po32[0][:,3] # Junction ID for splitting (will be overwritten at consolidation stage) po32 = newpool if __debug__: print "%6.3f time in rescale" % (time.clock()-clock) total = 0 longest = 0 for p in pool: total += len(p) longest = max(longest, len(p)) print 'pool:', len(pool), 'Avg:', total/(len(pool) or 1), 'Max:', longest print 'po32:', len(po32) # X-Plane 10 raster data raster={} elev=elevwidth=elevheight=None if 'SMED' in table: if __debug__: clock=time.clock() h.seek(table['SMED']) (l,)=unpack('<I', h.read(4)) demsend=h.tell()+l-8 layerno=0 while h.tell()<demsend: if h.read(4)!='IMED': raise IOError, baddsf (l,)=unpack('<I', h.read(4)) (ver,bpp,flags,width,height,scale,offset)=unpack('<BBHIIff', h.read(20)) if __debug__: print 'IMED', ver, bpp, flags, width, height, scale, offset, rasternames[layerno] if h.read(4)!='DMED': raise IOError, baddsf (l,)=unpack('<I', h.read(4)) assert l==8+bpp*width*height if flags&3==0: # float fmt='f' assert bpp==4 elif flags&3==3: raise IOError, baddsf else: # signed if bpp==1: fmt='b' elif bpp==2: fmt='h' elif bpp==4: fmt='i' else: raise IOError, baddsf if flags&3==2: # unsigned fmt=fmt.upper() data = fromstring(h.read(bpp*width*height), '<'+fmt).reshape(width,height) raster[rasternames[layerno]]=data if rasternames[layerno]=='elevation': # we're only interested in elevation assert flags&4 # algorithm below assumes post-centric data assert scale==1.0 and offset==0 # we don't handle other cases elev=raster['elevation'] elevwidth=width-1 elevheight=height-1 layerno+=1 if __debug__: print "%6.3f time in DEMS atom" % (time.clock()-clock) # Commands Atom if __debug__: clock=time.clock() # Processor time h.seek(table['SDMC']) (l,)=unpack('<I', h.read(4)) cmdsend=h.tell()+l-8 curpool=0 netbase=0 netcolor = COL_NETWORK netname = '#000' + NetworkDef.NETWORK idx=0 near=0 far=-1 flags=0 # 1=physical, 2=overlay roadtype=0 curter='terrain_Water' curpatch=[] tercache={'terrain_Water':(join('Resources','Sea01.png'), True, 0, 0.001,0.001)} stripindices = MakeStripIndices() fanindices = MakeFanIndices() if __debug__: cmds = defaultdict(int) while h.tell()<cmdsend: (c,)=unpack('<B', h.read(1)) if __debug__: cmds[c] += 1 #if __debug__: print "%08x %d" % (h.tell()-1, c) # Commands in rough order of frequency of use if c==10: # Network Chain Range (used by g2xpl and MeshTool) (first,last)=unpack('<HH', h.read(4)) #print "\nChain Range %d %d" % (first,last) if skipnetworks or last-first<2: pass elif wantoverlay: assert curpool==0, curpool placements.append(Network(netname, 0, [[Node(p) for p in po32[netbase+first:netbase+last]]])) else: assert curpool==0, curpool #assert not nodes[1:-2,3].any(), nodes # Only handle single complete chain nets[netcolor].append(po32[netbase+first:netbase+last]) elif c==9: # Network Chain (KSEA demo terrain uses this one) (l,)=unpack('<B', h.read(1)) #print "\nChain %d" % l if skipnetworks: h.read(l*2) elif wantoverlay: assert curpool==0, curpool placements.append(Network(netname, 0, [[Node(p) for p in po32[netbase+fromstring(h.read(l*2), '<H').astype(int)]]])) else: assert curpool==0, curpool #assert not nodes[1:-2,3].any(), nodes # Only handle single complete chain nets[netcolor].append(po32[netbase+fromstring(h.read(l*2), '<H').astype(int)]) elif c==11: # Network Chain 32 (KSEA demo terrain uses this one too) (l,)=unpack('<B', h.read(1)) #print "\nChain32 %d" % l if skipnetworks: h.read(l*4) elif wantoverlay: assert curpool==0, curpool placements.append(Network(netname, 0, [[Node(p) for p in po32[fromstring(h.read(l*4), '<I')]]])) else: assert curpool==0, curpool #assert not nodes[1:-2,3].any(), nodes # Only handle single complete chain nets[netcolor].append(po32[fromstring(h.read(l*4), '<I')]) elif c==13: # Polygon Range (DSF2Text uses this one) (param,first,last)=unpack('<HHH', h.read(6)) if not wantoverlay or last-first<2: continue winding=[] for d in range(first, last): p=pool[curpool][d] winding.append(p.tolist()) placements.append(Polygon.factory(polygons[idx], param, [winding])) elif c==15: # Nested Polygon Range (DSF2Text uses this one too) (param,n)=unpack('<HB', h.read(3)) i=[] for j in range(n+1): (l,)=unpack('<H', h.read(2)) i.append(l) if not wantoverlay: continue windings=[] for j in range(n): winding=[] for d in range(i[j],i[j+1]): p=pool[curpool][d] winding.append(p.tolist()) windings.append(winding) placements.append(Polygon.factory(polygons[idx], param, windings)) elif c==27: # Patch Triangle Strip - cross-pool (KSEA demo terrain uses this one) (l,)=unpack('<B', h.read(1)) #if __debug__: print '27: Triangle strip %d' % l if flags&1 and wantmesh: curpatch.append(array([pool[p][d] for (p,d) in fromstring(h.read(l*4), '<H').reshape(-1,2)])[stripindices[l]]) assert len(curpatch[-1]) == 3*(l-2), len(curpatch[-1]) else: h.seek(l*4, 1) elif c==28: # Patch Triangle Strip Range (KSEA demo terrain uses this one too) (first,last)=unpack('<HH', h.read(4)) #if __debug__: print '28: Triangle strip %d' % (last-first) if flags&1 and wantmesh: curpatch.append(pool[curpool][first:][stripindices[last-first]]) assert len(curpatch[-1]) == 3*(last-first-2), len(curpatch[-1]) elif c==1: # Coordinate Pool Select (curpool,)=unpack('<H', h.read(2)) elif c==2: # Junction Offset Select (netbase,)=unpack('<I', h.read(4)) #print "\nJunction Offset %d" % netbase elif c==3: # Set Definition (idx,)=unpack('<B', h.read(1)) elif c==4: # Set Definition (idx,)=unpack('<H', h.read(2)) elif c==5: # Set Definition (idx,)=unpack('<I', h.read(4)) elif c==6: # Set Road Subtype (roadtype,)=unpack('<B', h.read(1)) netcolor = roadtype in netdefs and netdefs[roadtype].color or COL_NETWORK netname = roadtype in netdefs and netdefs[roadtype].name or '#%03d%s' % (roadtype, NetworkDef.NETWORK) #print "\nRoad type %d" % roadtype elif c==7: # Object (d,)=unpack('<H', h.read(2)) p=pool[curpool][d] if wantoverlay: placements.append(Object.factory(objects[idx], p[1],p[0], round(p[2],1))) elif c==8: # Object Range (first,last)=unpack('<HH', h.read(4)) if wantoverlay: for d in range(first, last): p=pool[curpool][d] placements.append(Object.factory(objects[idx], p[1],p[0], round(p[2],1))) elif c==12: # Polygon (param,l)=unpack('<HB', h.read(3)) if not wantoverlay or l<2: h.read(l*2) continue winding=[] for i in range(l): (d,)=unpack('<H', h.read(2)) p=pool[curpool][d] winding.append(p.tolist()) placements.append(Polygon,factory(polygons[idx], param, [winding])) elif c==14: # Nested Polygon (param,n)=unpack('<HB', h.read(3)) windings=[] for i in range(n): (l,)=unpack('<B', h.read(1)) winding=[] for j in range(l): (d,)=unpack('<H', h.read(2)) p=pool[curpool][d] winding.append(p.tolist()) windings.append(winding) if wantoverlay and n>0 and len(windings[0])>=2: placements.append(Polygon.factory(polygons[idx], param, windings)) elif c==16: # Terrain Patch makemesh(mesh,path,curter,curpatch,south,west,elev,elevwidth,elevheight,terrains,tercache) #if __debug__: print '\n16: Patch, flags=%d' % flags curter=terrain[idx] curpatch=[] elif c==17: # Terrain Patch w/ flags makemesh(mesh,path,curter,curpatch,south,west,elev,elevwidth,elevheight,terrains,tercache) (flags,)=unpack('<B', h.read(1)) #if __debug__: print '\n17: Patch, flags=%d' % flags curter=terrain[idx] curpatch=[] elif c==18: # Terrain Patch w/ flags & LOD makemesh(mesh,path,curter,curpatch,south,west,elev,elevwidth,elevheight,terrains,tercache) (flags,near,far)=unpack('<Bff', h.read(9)) #if __debug__: print '18: Patch, flags=%d, lod=%d,%d' % (flags, near,far) assert near==0 # We don't currently handle LOD curter=terrain[idx] curpatch=[] elif c==23: # Patch Triangle (l,)=unpack('<B', h.read(1)) #if __debug__: print '23: Triangles %d' % l if flags&1 and wantmesh: curpatch.append(pool[curpool][fromstring(h.read(l*2), '<H')]) assert len(curpatch[-1]) == l, len(curpatch[-1]) else: h.seek(l*2, 1) elif c==24: # Patch Triangle - cross-pool (l,)=unpack('<B', h.read(1)) #if __debug__: print '24: Triangles %d' % l if flags&1 and wantmesh: curpatch.append(array([pool[p][d] for (p,d) in fromstring(h.read(l*4), '<H').reshape(-1,2)])) assert len(curpatch[-1]) == l, len(curpatch[-1]) else: h.seek(l*4, 1) elif c==25: # Patch Triangle Range (first,last)=unpack('<HH', h.read(4)) #if __debug__: print '25: Triangles %d' % (last-first) if flags&1 and wantmesh: curpatch.append(pool[curpool][first:last]) assert len(curpatch[-1]) == last-first, len(curpatch[-1]) elif c==26: # Patch Triangle Strip (used by g2xpl and MeshTool) (l,)=unpack('<B', h.read(1)) #if __debug__: print '26: Triangle strip %d' % l if flags&1 and wantmesh: curpatch.append(pool[curpool][fromstring(h.read(l*2), '<H')[stripindices[l]]]) assert len(curpatch[-1]) == 3*(l-2), len(curpatch[-1]) else: h.seek(l*2, 1) elif c==29: # Patch Triangle Fan (l,)=unpack('<B', h.read(1)) #if __debug__: print '29: Triangle fan %d' % l if flags&1 and wantmesh: curpatch.append(pool[curpool][fromstring(h.read(l*2), '<H')[fanindices[l]]]) assert len(curpatch[-1]) == 3*(l-2), len(curpatch[-1]) else: h.seek(l*2, 1) elif c==30: # Patch Triangle Fan - cross-pool (l,)=unpack('<B', h.read(1)) #if __debug__: print '30: Triangle fan %d' % l if flags&1 and wantmesh: curpatch.append(array([pool[p][d] for (p,d) in fromstring(h.read(l*4), '<H').reshape(-1,2)])[fanindices[l]]) assert len(curpatch[-1]) == 3*(l-2), len(curpatch[-1]) else: h.seek(l*4, 1) elif c==31: # Patch Triangle Fan Range (first,last)=unpack('<HH', h.read(4)) #if __debug__: print '31: Triangle fan %d' % (last-first) if flags&1 and wantmesh: curpatch.append(pool[curpool][first:][fanindices[last-first]]) assert len(curpatch[-1]) == 3*(last-first-2), len(curpatch[-1]) elif c==32: # Comment (l,)=unpack('<B', h.read(1)) h.read(l) elif c==33: # Comment (l,)=unpack('<H', h.read(2)) h.read(l) elif c==34: # Comment (l,)=unpack('<I', h.read(4)) h.read(l) else: if __debug__: print "Unrecognised command (%d) at %x" % (c, h.tell()-1) raise IOError, (c, "Unrecognised command (%d)" % c, path) # Last one makemesh(mesh,path,curter,curpatch,south,west,elev,elevwidth,elevheight,terrains,tercache) if __debug__: print "%6.3f time in CMDS atom" % (time.clock()-clock) print 'Stats:' for cmd in sorted(cmds.keys()): print cmd, cmds[cmd] if not wantoverlay: print "%d patches, avg subsize %s" % (makemesh.count, makemesh.total/makemesh.count) h.close() # consolidate mesh for k,v in mesh.iteritems(): mesh[k] = concatenate(v) if len(terrain)>1 and 'g2xpl' in terrain[1]: # Post-processing for g2xpl-generated meshes. This is slow so only do it if a g2xpl texture is used. if __debug__: clock=time.clock() for k,v in mesh.iteritems(): # sort vertices of each triangle dtype = [('x1',float32), ('y1',float32), ('z1',float32), ('u1',float32), ('v1',float32), ('x2',float32), ('y2',float32), ('z2',float32), ('u2',float32), ('v2',float32), ('x3',float32), ('y3',float32), ('z3',float32), ('u3',float32), ('v3',float32)] v = v.reshape((-1,15)) v1 = v.view(dtype) v2 = roll(v, -5, axis=1).view(dtype) v3 = roll(v, -10, axis=1).view(dtype) v12= where(logical_or(v2['x1'] > v1['x1'], logical_and(v2['x1'] == v1['x1'], v2['z1'] > v1['z1'])), v2, v1) v = where(logical_or(v3['x1'] >v12['x1'], logical_and(v3['x1'] ==v12['x1'], v3['z1'] >v12['z1'])), v3, v12) # remove negatives - calculate cross product at middle point p2 # http://paulbourke.net/geometry/polygonmesh/ "... vertices ordered clockwise or counterclockwise" v = v[(v['x2']-v['x1']) * (v['z3']-v['z2']) - (v['z2']-v['z1']) * (v['x3']-v['x2']) > 0] # Remove dupes. numpy.unique() only works on 1D arrays - # http://mail.scipy.org/pipermail/numpy-discussion/2010-September/052877.html v = unique(v) mesh[k] = v.view(float32).reshape((-1,5)) if __debug__: print "%6.3f time in g2xpl post-processing" % (time.clock()-clock) # apply colors to network points, consolidate and create indices for drawing # FIXME: speed this up if nets: counts = [] # points in each chain newnets = [] for color, cnets in nets.iteritems(): counts.extend([len(chain) for chain in cnets]) cnets = vstack(cnets) cnets[:,3:6] = color # apply color across all points newnets.append(cnets) newnets = vstack(newnets) counts = array(counts, int) start = cumsum(concatenate((zeros((1,), int), counts)))[:-1] end = start + counts - 1 indices= concatenate([repeat(arange(start[i],end[i],1,GLuint), 2) for i in range(len(counts))]) indices[1::2] += 1 assert (len(indices) == (sum(counts)-len(counts))*2) nets = (newnets, indices) else: nets = None if bbox: # filter to bounding box if bytype is Object: placements = [p for p in placements if p.inside(bbox) and (isinstance(p, Object) or isinstance(p, AutoGenBlock) or isinstance(p, AutoGenString))] # filter by type, including AutoGenPoints elif bytype: placements = [p for p in placements if p.inside(bbox) and p.__class__ is bytype] # filter by type, excluding derived else: if bytype is Object: placements = [p for p in placements if isinstance(p, Object) or isinstance(p, AutoGenBlock) or isinstance(p, AutoGenString)] # filter by type, including AutoGenPoints elif bytype: placements = [p for p in placements if p.__class__ is bytype] # filter by type, excluding derived return (south, west, placements, nets, mesh)
def on_graph(self, graph_response): """ TODO: clean this up using templates """ if graph_response.error is not None: print "Got error from API server" graph_response.rethrow() if graph_response.code != 200: print "Got response code %s from API server" % graph_response.code self.send_error(graph_response.code) # TODO: figure out the interface for this # TODO: if there are too many nodes, we need to prune the view # One idea: do a Dijkstra from all running nodes. Hide all nodes # with distance >= 50. tasks = json.loads(graph_response.body)["response"] graphviz = pygraphviz.AGraph(directed=True, size=12) n_nodes = 0 for task, p in tasks.iteritems(): selector = p['status'] if selector == PENDING and not p['workers']: selector = 'BROKEN' colors = { PENDING: ('white', 'black'), DONE: ('green', 'white'), FAILED: ('red', 'white'), RUNNING: ('blue', 'white'), 'BROKEN': ('orange', 'black'), # external task, can't run } fillcolor = colors[selector][0] fontcolor = colors[selector][1] shape = 'box' label = task.replace('(', '\\n(').replace( ',', ',\\n') # force GraphViz to break lines # TODO: if the ( or , is a part of the argument we shouldn't really break it # TODO: FIXME: encoding strings is not compatible with newer pygraphviz graphviz.add_node(task.encode('utf-8'), label=label.encode('utf-8'), style='filled', fillcolor=fillcolor, fontcolor=fontcolor, shape=shape, fontname='Helvetica', fontsize=11) n_nodes += 1 for task, p in tasks.iteritems(): for dep in p['deps']: graphviz.add_edge(dep, task) if n_nodes < 200: graphviz.layout('dot') else: # stupid workaround... graphviz.layout('fdp') s = StringIO() graphviz.draw(s, format='svg') s.seek(0) svg = s.read() # TODO: this code definitely should not live here: html_header = pkg_resources.resource_string(__name__, 'static/header.html') pattern = r'(<svg.*?)(<g id="graph1".*?)(</svg>)' mo = re.search(pattern, svg, re.S) self.write(''.join([ html_header, mo.group(1), '<g id="viewport">', mo.group(2), '</g>', mo.group(3), "</body></html>" ])) self.finish()
def print_report(self): self.ensure_one() print('ensure_one = ', self.ensure_one()) context = dict(self._context or {}) # Header Section date_from = self.date_from date_to = self.date_to now = datetime.now() date_now = now.strftime('%d/%b/%Y') time_now = now.strftime('%H:%M') year = now.strftime('%Y') company_name = self.company_id.name all_employee = self.env['hr.employee'].search([('company_id', '=', self.company_id.id)]) print('all_employee = ', all_employee) company_name = company_name.upper() dhm = 'Day - Hour:Minute' chm = 'Count - Hour:Minute' ########################## # Leave Section all_leave = self.env['hr.holidays.status'].search([]) all_leave_name = [] for leave in self.holiday_status_ids: if leave.name not in all_leave_name: all_leave_name.append(leave.name) # ########################3333 workbook = xlwt.Workbook() header1 = xlwt.easyxf( 'font: bold on, color black, name Arial; align: wrap yes, ,vert bottom ,horz centre' ) title1 = xlwt.easyxf( 'font: color black, name Arial; align: wrap yes, vert centre ,horz centre' ) title_total = xlwt.easyxf( 'font: color black, name Arial; align: wrap yes, horz centre; pattern: pattern solid, fore_color gray40' ) name = xlwt.easyxf( 'font: color black, name Arial; align: wrap yes, ,vert centre ,horz left' ) for dept in self.dept_ids: j = 0 i = 0 worksheet = workbook.add_sheet(dept.name) worksheet.write(0, j + 5, company_name, header1) worksheet.write(0, j + 10, date_now, title1) worksheet.write(1, j + 10, time_now, title1) worksheet.write( 2, j + 5, str(date_from) + ' - ' + str(date_to) + ' Year ' + str(year), title1) worksheet.write(4, j + 2, dhm, title1) worksheet.write(4, j + 3, chm, title1) worksheet.write(4, j + 4, chm, title1) worksheet.col(0 + j).width = 11000 worksheet.col(1 + j).width = 8000 worksheet.col(2 + j).width = 8000 worksheet.col(3 + j).width = 8000 worksheet.col(4 + j).width = 8000 worksheet.row(5).height = 600 worksheet.write(5, j + 1, 'Join Date', title1) worksheet.write(5, j + 2, 'Absent/Not Clock', title1) worksheet.write(5, j + 3, 'Late', title1) worksheet.write(5, j + 4, 'Leave Early', title1) j = 5 all_leave_name.sort() print('all_leave_name = ', all_leave_name) for l in all_leave_name: if j == 5: worksheet.col(j).width = 11000 else: worksheet.col(j).width = 8000 worksheet.write(4, j, dhm, title1) worksheet.write(5, j, l, title1) j += 1 worksheet.col(j + 0).width = 8000 worksheet.col(j + 1).width = 10000 worksheet.col(j + 2).width = 8000 worksheet.col(j + 3).width = 8000 worksheet.write(4, j + 0, 'Hour', title1) worksheet.write(4, j + 1, 'Hours', title1) worksheet.write(5, j + 0, 'Working Hours', title1) worksheet.write( 5, j + 1, 'Absent + late + leave early + all leaves excl. annual leave', title1) worksheet.write(5, j + 2, '% Loss of worktime', title1) worksheet.write(5, j + 3, '% Remaining of worktime', title1) i = 7 k = 0 print('j = ', j) # Count Section absent = 0 late_total = 0 late_length_total = 0.00 early_total = 0 early_length_total = 0.00 for employee in all_employee.filtered( lambda x: x.department_id == dept): count_employee_absent = self.count_employee_absent( employee, date_from, date_to) absent += count_employee_absent emp_late_early = self.count_emp_late_early( employee, date_from, date_to) late_total += emp_late_early['total_late'] late_length_total += emp_late_early['length_late'] early_total += emp_late_early['total_leave_early'] early_length_total += emp_late_early['length_leave_early'] late = emp_late_early['late'] early = emp_late_early['leave_early'] worksheet.write(i, k + 0, employee.employee_no + ' ' + employee.name, name) worksheet.write(i, k + 1, employee.join_date, title1) worksheet.write(i, k + 2, str(count_employee_absent) + ' - 00:00', title1) worksheet.write(i, k + 3, late, title1) worksheet.write(i, k + 4, early, title1) all_leave_name.sort() ls = 5 for p in all_leave_name: holiday_type_id = self.env['hr.holidays.status'].search([ ('name', '=', p) ]) count_holiday = self.count_leave(employee, date_from, date_to, holiday_type_id.id) worksheet.write(i, ls, count_holiday, title1) ls += 1 i += 1 absent_to_display = str(absent) + ' - 00:00' late_to_display = self.converse_late_early(late_total, late_length_total) leave_early_to_display = self.converse_late_early( early_total, early_length_total) for t in range(0, (j + 4), 1): if t == 2: worksheet.write(6, t, absent_to_display, title_total) elif t == 3: worksheet.write(6, t, late_to_display, title_total) elif t == 4: worksheet.write(6, t, leave_early_to_display, title_total) else: worksheet.write(6, t, None, title_total) fp = StringIO() workbook.save(fp) fp.seek(0) data = fp.read() fp.close() res = base64.encodestring(data) mod_rec = self.env['sum.att.xls.report'].create({ 'name': 'Summary Attendance Report.xls', 'file': res }) return { 'name': _('Summary Attendance Report'), 'res_id': mod_rec.id, 'view_type': 'form', "view_mode": 'form', 'res_model': 'sum.att.xls.report', 'type': 'ir.actions.act_window', 'target': 'new', }
class MARCReader(Reader): """ An iterator class for reading a file of MARC21 records. Simple usage: from pymarc import MARCReader ## pass in a file object reader = MARCReader(file('file.dat')) for record in reader: ... ## pass in marc in transmission format reader = MARCReader(rawmarc) for record in reader: ... If you would like to have your Record object contain unicode strings use the to_unicode parameter: reader = MARCReader(file('file.dat'), to_unicode=True) This will decode from MARC-8 or UTF-8 depending on the value in the MARC leader at position 9. If you find yourself in the unfortunate position of having data that is utf-8 encoded without the leader set appropriately you can use the force_utf8 parameter: reader = MARCReader(file('file.dat'), to_unicode=True, force_utf8=True) If you find yourself in the unfortunate position of having data that is mostly utf-8 encoded but with a few non-utf-8 characters, you can also use the utf8_handling parameter, which takes the same values ('strict', 'replace', and 'ignore') as the Python Unicode codecs (see http://docs.python.org/library/codecs.html for more info). """ def __init__(self, marc_target, to_unicode=False, force_utf8=False, hide_utf8_warnings=False, utf8_handling='strict'): """ The constructor to which you can pass either raw marc or a file-like object. Basically the argument you pass in should be raw MARC in transmission format or an object that responds to read(). """ super(MARCReader, self).__init__() self.to_unicode = to_unicode self.force_utf8 = force_utf8 self.hide_utf8_warnings = hide_utf8_warnings self.utf8_handling = utf8_handling if (hasattr(marc_target, "read") and callable(marc_target.read)): self.file_handle = marc_target else: self.file_handle = StringIO(marc_target) def next(self): """ To support iteration. """ first5 = self.file_handle.read(5) if not first5: raise StopIteration if len(first5) < 5: raise RecordLengthInvalid length = int(first5) chunk = self.file_handle.read(length - 5) chunk = first5 + chunk record = Record(chunk, to_unicode=self.to_unicode, force_utf8=self.force_utf8, hide_utf8_warnings=self.hide_utf8_warnings, utf8_handling=self.utf8_handling) return record
class Buffer(object): def __init__(self, fp): if not hasattr(fp, 'read'): self.fp = StringIO(fp) else: self.fp = fp @property def pos(self): return self.fp.tell() @pos.setter def pos(self, pos): self.fp.seek(pos) def __len__(self): temp = self.pos self.fp.seek(0, 2) ret = self.pos self.pos = temp return ret def __iadd__(self, o): self.pos += o return self def __isub__(self, o): self.pos -= o return self def read(self, count): return self.fp.read(count) def uint(self, count=None): if count is None: return unpack('<I', self.read(4))[0] return unpack('<' + 'I' * count, self.read(4 * count)) def int(self, count=None): if count is None: return unpack('<i', self.read(4))[0] return unpack('<' + 'i' * count, self.read(4 * count)) def ushort(self, count=None): if count is None: return unpack('<H', self.read(2))[0] return unpack('<' + 'H' * count, self.read(2 * count)) def short(self, count=None): if count is None: return unpack('<h', self.read(2))[0] return unpack('<' + 'h' * count, self.read(2 * count)) def uchar(self, count=None): if count is None: return unpack('<B', self.read(1))[0] return unpack('<' + 'B' * count, self.read(count)) def char(self, count=None): if count is None: return unpack('<b', self.read(1))[0] return unpack('<' + 'b' * count, self.read(count)) def float(self, count=None): if count is None: return unpack('<f', self.read(4))[0] return unpack('<' + 'f' * count, self.read(4 * count)) def vec3(self, count=None): if count is None: return unpack('<fff', self.read(12)) return tuple(unpack('<fff', self.read(12)) for i in xrange(count))
def patches(a, bins): if not bins: return a plens = [len(x) for x in bins] pl = sum(plens) bl = len(a) + pl tl = bl + bl + pl # enough for the patches and two working texts b1, b2 = 0, bl if not tl: return a m = StringIO() def move(dest, src, count): """move count bytes from src to dest The file pointer is left at the end of dest. """ m.seek(src) buf = m.read(count) m.seek(dest) m.write(buf) # load our original text m.write(a) frags = [(len(a), b1)] # copy all the patches into our segment so we can memmove from them pos = b2 + bl m.seek(pos) for p in bins: m.write(p) def pull(dst, src, l): # pull l bytes from src while l: f = src.pop() if f[0] > l: # do we need to split? src.append((f[0] - l, f[1] + l)) dst.append((l, f[1])) return dst.append(f) l -= f[0] def collect(buf, list): start = buf for l, p in reversed(list): move(buf, p, l) buf += l return (buf - start, start) for plen in plens: # if our list gets too long, execute it if len(frags) > 128: b2, b1 = b1, b2 frags = [collect(b1, frags)] new = [] end = pos + plen last = 0 while pos < end: m.seek(pos) p1, p2, l = struct.unpack(">lll", m.read(12)) pull(new, frags, p1 - last) # what didn't change pull([], frags, p2 - p1) # what got deleted new.append((l, pos + 12)) # what got added pos += l + 12 last = p2 frags.extend(reversed(new)) # what was left at the end t = collect(b2, frags) m.seek(t[1]) return m.read(t[0])
def get_all_objects(text, beginning=r'{', debug=False): """ Zealous obtainer of mappings from a text, e.g. in javascript or JSON or whatever. Anything between '{' and '}' The monstrous advanced version. Not performant. Requires pyyaml. >>> st = 'a str with var stuff = {a: [{"v": 12}]} and such' >>> next(get_all_objects(st)) {'a': [{'v': 12}]} """ def _dbg_actual(st, *ar): print "D: ", st % ar _dbg = _dbg_actual if debug else (lambda *ar: None) import yaml # Allow any escape to be treated as the character itself. class ddd(dict): def __getitem__(self, key): try: return dict.__getitem__(self, key) except KeyError: self.__setitem__(key, key) return key class TheLoader(yaml.SafeLoader): ESCAPE_REPLACEMENTS = ddd(yaml.SafeLoader.ESCAPE_REPLACEMENTS) from cStringIO import StringIO # optimised slicing if isinstance(text, unicode): _dbg("encoding") text = text.encode('utf-8') _dbg("Length: %r", len(text)) beginnings = list(indexall_re(text, beginning)) _dbg("Beginnings amount: %r", len(beginnings)) _dbg("Beginnings list: %r", beginnings[:15] + (beginnings[15:] and ['...'])) text = StringIO(text) for from_ in beginnings: current_pos = text.tell() _dbg("At %r", current_pos) # if from_ < current_pos: # _dbg("Skipping the beginning %r" % (from_,)) # # NOTE: this will skip the recursed structures. # # Which is quite helpful. # continue text.seek(from_) loader = TheLoader(text) try: art_res = loader.get_data() except Exception as exc: _dbg("Nope: %r / %s / %r", exc, exc, exc.args) text.seek(from_) _dbg("Stuff was: %r", repr(text.read(50)).decode('string-escape')) continue assert isinstance(part_res, dict) yield part_res
def __str__(self): from cStringIO import StringIO s = StringIO() msg = self.show(out=s) s.seek(0) return s.read()
class AppendedFiles(): """ Two WormHoleFiles one after another. Takes 1 or 2 dict(s) as arguments; they're passed to WormHoleFiles' at the init. This is aimed at merging the TOC track starting at LBA45000 with the last one to mimic one big track at LBA0 with the files at the same LBA than the GD-ROM. """ def __init__(self, wormfile1, wormfile2=None, *args, **kwargs): self._f1 = WormHoleFile(**wormfile1) self._f1.seek(0, 2) self._f1_len = self._f1.tell() self._f1.seek(0, 0) self._f2_len = 0 if wormfile2: self._f2 = WormHoleFile(**wormfile2) self._f2.seek(0, 2) self._f2_len = self._f2.tell() self._f2.seek(0, 0) else: # So the rest of the code works for one or 2 files. self._f2 = StringIO('') self.seek(0, 0) def seek(self, a, b=0): if b == 0: self.MetaPointer = a if b == 1: self.MetaPointer += a if b == 2: self.MetaPointer = self._f1_len + self._f2_len - a if self.MetaPointer >= self._f1_len: self._f1.seek(0, 2) self._f2.seek(a - self._f1_len, 0) else: self._f1.seek(a, 0) self._f2.seek(0, 0) def read(self, length=None): if length == None: length = self._f1_len + self._f2_len - self.MetaPointer tmp = self.MetaPointer FutureOffset = self.MetaPointer + length if FutureOffset < self._f1_len: # Read inside file1 data = self._f1.read(length) elif tmp > self._f1_len: # Read inside file2 data = self._f2.read(length) else: # Read end of file1 and start of file2 data = self._f1.read(self._f1_len - tmp) data += self._f2.read(FutureOffset - self._f1_len) self.seek(FutureOffset) # It might be enough to just update # self.MetaPointer, but this is safer. return data def tell(self): return self.MetaPointer def __enter__(self): return self def __exit__(self, type=None, value=None, traceback=None): # This is required to close files properly when using the with # statement. Which isn't required by ISO9660 anymore, but could # be useful for other uses so it stays! self._f1.__exit__() if self._f2_len: self._f2.__exit__()
class HttpRequest(object): """A basic HTTP request.""" # The encoding used in GET/POST dicts. None means use default setting. _encoding = None _upload_handlers = [] def __init__(self): self.GET, self.POST, self.COOKIES, self.META, self.FILES = {}, {}, {}, {}, {} self.path = '' self.path_info = '' self.method = None def __repr__(self): return '<HttpRequest\nGET:%s,\nPOST:%s,\nCOOKIES:%s,\nMETA:%s>' % \ (pformat(self.GET), pformat(self.POST), pformat(self.COOKIES), pformat(self.META)) def get_host(self): """Returns the HTTP host using the environment or request headers.""" # We try three options, in order of decreasing preference. if settings.USE_X_FORWARDED_HOST and ( 'HTTP_X_FORWARDED_HOST' in self.META): host = self.META['HTTP_X_FORWARDED_HOST'] elif 'HTTP_HOST' in self.META: host = self.META['HTTP_HOST'] else: # Reconstruct the host using the algorithm from PEP 333. host = self.META['SERVER_NAME'] server_port = str(self.META['SERVER_PORT']) if server_port != (self.is_secure() and '443' or '80'): host = '%s:%s' % (host, server_port) return host def get_full_path(self): # RFC 3986 requires query string arguments to be in the ASCII range. # Rather than crash if this doesn't happen, we encode defensively. return '%s%s' % (self.path, self.META.get('QUERY_STRING', '') and ('?' + iri_to_uri(self.META.get('QUERY_STRING', ''))) or '') def build_absolute_uri(self, location=None): """ Builds an absolute URI from the location and the variables available in this request. If no location is specified, the absolute URI is built on ``request.get_full_path()``. """ if not location: location = self.get_full_path() if not absolute_http_url_re.match(location): current_uri = '%s://%s%s' % (self.is_secure() and 'https' or 'http', self.get_host(), self.path) location = urljoin(current_uri, location) return iri_to_uri(location) def is_secure(self): return os.environ.get("HTTPS") == "on" def is_ajax(self): return self.META.get('HTTP_X_REQUESTED_WITH') == 'XMLHttpRequest' def _set_encoding(self, val): """ Sets the encoding used for GET/POST accesses. If the GET or POST dictionary has already been created, it is removed and recreated on the next access (so that it is decoded correctly). """ self._encoding = val if hasattr(self, '_get'): del self._get if hasattr(self, '_post'): del self._post def _get_encoding(self): return self._encoding encoding = property(_get_encoding, _set_encoding) def _initialize_handlers(self): self._upload_handlers = [uploadhandler.load_handler(handler, self) for handler in settings.FILE_UPLOAD_HANDLERS] def _set_upload_handlers(self, upload_handlers): if hasattr(self, '_files'): raise AttributeError("You cannot set the upload handlers after the upload has been processed.") self._upload_handlers = upload_handlers def _get_upload_handlers(self): if not self._upload_handlers: # If thre are no upload handlers defined, initialize them from settings. self._initialize_handlers() return self._upload_handlers upload_handlers = property(_get_upload_handlers, _set_upload_handlers) def parse_file_upload(self, META, post_data): """Returns a tuple of (POST QueryDict, FILES MultiValueDict).""" self.upload_handlers = ImmutableList( self.upload_handlers, warning = "You cannot alter upload handlers after the upload has been processed." ) parser = MultiPartParser(META, post_data, self.upload_handlers, self.encoding) return parser.parse() def _get_raw_post_data(self): if not hasattr(self, '_raw_post_data'): if self._read_started: raise Exception("You cannot access raw_post_data after reading from request's data stream") try: content_length = int(self.META.get('CONTENT_LENGTH', 0)) except (ValueError, TypeError): # If CONTENT_LENGTH was empty string or not an integer, don't # error out. We've also seen None passed in here (against all # specs, but see ticket #8259), so we handle TypeError as well. content_length = 0 if content_length: self._raw_post_data = self.read(content_length) else: self._raw_post_data = self.read() self._stream = StringIO(self._raw_post_data) return self._raw_post_data raw_post_data = property(_get_raw_post_data) def _mark_post_parse_error(self): self._post = QueryDict('') self._files = MultiValueDict() self._post_parse_error = True def _load_post_and_files(self): # Populates self._post and self._files if self.method != 'POST': self._post, self._files = QueryDict('', encoding=self._encoding), MultiValueDict() return if self._read_started and not hasattr(self, '_raw_post_data'): self._mark_post_parse_error() return if self.META.get('CONTENT_TYPE', '').startswith('multipart'): if hasattr(self, '_raw_post_data'): # Use already read data data = StringIO(self._raw_post_data) else: data = self try: self._post, self._files = self.parse_file_upload(self.META, data) except: # An error occured while parsing POST data. Since when # formatting the error the request handler might access # self.POST, set self._post and self._file to prevent # attempts to parse POST data again. # Mark that an error occured. This allows self.__repr__ to # be explicit about it instead of simply representing an # empty POST self._mark_post_parse_error() raise else: self._post, self._files = QueryDict(self.raw_post_data, encoding=self._encoding), MultiValueDict() ## File-like and iterator interface. ## ## Expects self._stream to be set to an appropriate source of bytes by ## a corresponding request subclass (WSGIRequest or ModPythonRequest). ## Also when request data has already been read by request.POST or ## request.raw_post_data, self._stream points to a StringIO instance ## containing that data. def read(self, *args, **kwargs): self._read_started = True return self._stream.read(*args, **kwargs) def readline(self, *args, **kwargs): self._read_started = True return self._stream.readline(*args, **kwargs) def xreadlines(self): while True: buf = self.readline() if not buf: break yield buf __iter__ = xreadlines def readlines(self): return list(iter(self))
def start_export(request): if request.method == 'POST': #We retrieve all selected exporters listExporter = request.POST.getlist('my_exporters') instances = request.session['instancesExplore'] listId = request.session['listIdToExport'] xmlResults = [] #Creation of ZIP file in_memory = StringIO() zip = zipfile.ZipFile(in_memory, "a") is_many_inst = len(instances) > 1 for instance in instances: #Retrieve data sessionName = "resultsExplore" + eval(instance)['name'] results = request.session[sessionName] if (len(results) > 0): for result in results: if result['id'] in listId: xmlResults.append(result) #For each data, we convert if len(xmlResults) > 0: #Init the folder name folder_name = None if is_many_inst: folder_name = eval(instance)['name'] #Check if the XSLT converter is asked. If yes, we start with this one because there is a specific treatment listXslt = request.POST.getlist('my_xslts') #Get the content of the file if len(listXslt) > 0: exporter = XSLTExporter() for xslt in listXslt: xslt = ExporterXslt.objects.get(pk=xslt) exporter._setXslt(xslt.content) if folder_name == None: exporter._transformAndZip(xslt.name, xmlResults, zip) else: exporter._transformAndZip( folder_name + "/" + xslt.name, xmlResults, zip) #We export for others exporters for exporter in listExporter: exporter = get_exporter(exporter) exporter._transformAndZip(folder_name, xmlResults, zip) zip.close() #ZIP file to be downloaded in_memory.seek(0) response = HttpResponse(in_memory.read()) response["Content-Disposition"] = "attachment; filename=Results.zip" response['Content-Type'] = 'application/x-zip' request.session['listIdToExport'] = '' return response else: # We retrieve the result_id for each file the user wants to export listId = request.GET.getlist('listId[]') request.session['listIdToExport'] = listId # Get all schemaId from the listId listSchemas = XMLdata.getByIDsAndDistinctBy(listId, "schema") # XMLdata.objects(pk__in=listId).distinct(field="schema") export_form = ExportForm(listSchemas) upload_xslt_Form = UploadXSLTForm(listSchemas) template = loader.get_template('explore/export_start.html') context = Context({ 'export_form': export_form, 'upload_xslt_Form': upload_xslt_Form, 'nb_elts_exp': len(export_form.EXPORT_OPTIONS), 'nb_elts_xslt': len(upload_xslt_Form.EXPORT_OPTIONS) }) return HttpResponse(json.dumps({'template': template.render(context)}), content_type='application/javascript')
def download(request): """ Preps the download from the form post and delivers it Uses the JSON encoded grids and loops over them building the css, js and images required for all to work correctly Args: request """ # redirect if it's not a post if request.method != 'POST': return HttpResponseRedirect('/') # Ensure our formatting is solid try: grids = json.loads(request.POST['grids']) except ValueError: # Raised if grid is poorly formatted raise Http404 max_cols = 0 # Set up a string buffer for the zip (we'll serve it from memory) zip_buff = StringIO() zip_dl = ZipFile(zip_buff, 'w') """ Create a PNG for each grid ---------------------------------------------------------------------------- """ for g in grids: # Work out which grid has the highest number of cols if g['col_num'] > max_cols: max_cols = g['col_num'] # Instantiate a Grid model object grid = Grid( min_width=g['min_width'], col_num=g['col_num'], padding_width=g['padding_width'], padding_type=g['padding_type'], gutter_width=g['gutter_width'], gutter_type=g['gutter_type'], upper=g['upper'], ) # Draw the image into a string io buffer im_buff = grid.create_image() # If upper is false, set a better name if g['upper'] == False: upper_name = 'infinity' else: upper_name = g['upper'] # Save the grid to the zip with a decent name im_name = "grid-%s_to_%s.png" % (g['min_width'], upper_name) zip_dl.writestr(im_name, im_buff.getvalue()) """ Build the zip file in memory and serve it up ---------------------------------------------------------------------------- """ # A list of the templates we want to render and add to our zip templates = [ 'grids/downloads/gridpak.css', 'grids/downloads/gridpak.js', 'grids/downloads/gridpak.less', 'grids/downloads/gridpak.scss', 'grids/downloads/README.md', ] # Loop the templates list for template in templates: buff = StringIO() # Read the templates into string buffers buff.write( render_to_string(template, { 'grids': grids, 'max_cols': max_cols, }).encode('ascii', 'ignore')) zip_dl.writestr(template.replace('grids/downloads/', ''), buff.getvalue()) # Now add the demo directory as is path = os.path.join(settings.CUR_DIR, 'templates/grids/downloads/demo') for root, dirs, files in os.walk(path): for filename in files: # Writes the file to the zip inside one dir called demo zip_dl.write(os.path.join(root, filename), os.path.join('demo', filename)) zip_dl.close() response = HttpResponse(mimetype='application/zip') response['Content-Disposition'] = 'attachment; filename=gridpak.zip' zip_buff.seek(0) response.write(zip_buff.read()) return response
def print_sg_leave_summary_report_wizard(self): cr, uid, context = self.env.args if context is None: context = {} context = dict(context) user_obj = self.env['res.users'].search([]) ids = self.env['hr.employee'].search([('user_id', '=', uid)]) data = self.read()[0] if 'all_employee' or 'all_leave' in data: context.update({ 'all_employee': data['all_employee'], 'all_leave': data['all_leave'] }) context.update({ 'from_date': data['from_date'], 'to_date': data['to_date'], 'leave_type_id': data['leave_type_id'], 'employee_id': data['employee_id'] }) workbook = xlwt.Workbook() worksheet = workbook.add_sheet('Sheet 1') borders = xlwt.Borders() border_style = xlwt.XFStyle() # Create Style font = xlwt.Font() font.bold = True table_border = xlwt.easyxf('font: bold 1, height 200; align: wrap on;') table_border1 = xlwt.easyxf('font: height 200; align: wrap on;') table_border_center = xlwt.easyxf( "font: bold 0; align: wrap on, horiz centre;") table_border1_center = xlwt.easyxf("align: wrap on, horiz centre;") borders.top = xlwt.Borders.MEDIUM borders.bottom = xlwt.Borders.MEDIUM borders.left = xlwt.Borders.MEDIUM borders.right = xlwt.Borders.MEDIUM table_border.borders = borders table_border1.borders = borders table_border_center.borders = borders table_border1_center.borders = borders header = xlwt.easyxf('font: bold 1, height 300', 'align: center') header2 = xlwt.easyxf('font: bold 1, height 200', 'align: left') header3 = xlwt.easyxf('font: bold 1 , height 250', 'align: left') header1 = xlwt.easyxf("align: wrap on;") borders.top = xlwt.Borders.MEDIUM borders.bottom = xlwt.Borders.MEDIUM borders.left = xlwt.Borders.MEDIUM borders.right = xlwt.Borders.MEDIUM header1.borders = borders worksheet.col(0).width = 7000 worksheet.col(1).width = 7000 worksheet.col(2).width = 7000 worksheet.col(3).width = 7000 worksheet.col(4).width = 7000 worksheet.col(5).width = 6000 worksheet.col(6).width = 6000 worksheet.col(7).width = 6000 worksheet.col(8).width = 6000 worksheet.col(9).width = 7000 worksheet.row(0).height = 600 worksheet.row(1).height = 300 worksheet.row(2).height = 400 worksheet.row(3).height = 300 worksheet.row(4).height = 300 worksheet.row(5).height = 400 worksheet.row(6).height = 300 worksheet.row(7).height = 300 worksheet.row(8).height = 400 worksheet.row(9).height = 300 # path = os.path.abspath(os.path.dirname(__file__)) # path += '/../static/img/abced.bmp' # worksheet.insert_bitmap(path,0,2,1) worksheet.write_merge(0, 0, 3, 5, ids.company_id.name, header) emp_obj = self.env['hr.employee'] if context["employee_id"]: emp_record = self.env['hr.employee'].browse( context["employee_id"][0]) department = emp_record.department_id and emp_record.department_id.name or '' emp_no = emp_record.identification_id or '' emp_title = emp_record.job_id and emp_record.job_id.name or '' joined_year = emp_record.joined_year or '' leave_structure = emp_record.leave_config_id and emp_record.leave_config_id.name or '' else: employee_res = self.env['hr.employee'].search([]) leave_obj = self.env['hr.holidays.status'] holiday_obj = self.env['hr.holidays'] if context['all_leave'] == True: leave_ids = leave_obj.search([]) args = [('date_start', '<=', context.get('from_date')), ('date_stop', '>=', context.get('to_date'))] fiscalyear_id = self.env['hr.year'].search(args) if fiscalyear_id: fiscalyear_id = fiscalyear_id[0] else: raise ValidationError(_('You can search only single year records')) from_date_date = datetime.strptime( context["from_date"] + " 00:00:00", DEFAULT_SERVER_DATETIME_FORMAT) - relativedelta(hours=8) from_date_str = from_date_date.strftime(DEFAULT_SERVER_DATETIME_FORMAT) from_to_date = datetime.strptime( context["to_date"] + " 23:59:59", DEFAULT_SERVER_DATETIME_FORMAT) - relativedelta(hours=8) from_to_str = from_to_date.strftime(DEFAULT_SERVER_DATETIME_FORMAT) # WHEN BOTH CHECKBOX IS TRUE if context['all_employee'] == True and context['all_leave'] == True: row = 2 col = 0 self._get_company_info(worksheet, row, header2) row = row + 4 worksheet.row(row + 4).height = 300 leave_name = '' leave_ids = leave_obj.search([]) for leave in leave_ids: row = row + 1 worksheet.row(row).height = 300 worksheet.row(row + 2).height = 600 leave_name = leave.name2 if leave.name2 else leave.name worksheet.write_merge(row, row, col, 2, leave_name, header3) self._get_employee_header(worksheet, row, table_border) row = row + 3 col = 0 for emp_record in employee_res: emp_id = emp_record.id leave_id = leave.id # DEPARTMENT if emp_record.department_id and emp_record.department_id.name: worksheet.write(row, col + 0, emp_record.department_id.name, table_border1) else: worksheet.write(row, col + 0, '', table_border1) # IDENTIFICATION NUMBER if emp_record.identification_id: worksheet.write(row, col + 1, emp_record.identification_id, table_border1) else: worksheet.write(row, col + 1, '', table_border1) # EMPLOYEE NAME if emp_record.name: worksheet.write(row, col + 2, emp_record.name, table_border1) else: worksheet.write(row, col + 2, '', table_border1) # DATE JOINED if emp_record.join_date: emp_j_date = datetime.strptime( emp_record.join_date, DEFAULT_SERVER_DATE_FORMAT) emp_join_dt = str( emp_j_date.strftime('%d')) + '-' + str( emp_j_date.strftime('%m')) + '-' + str( emp_j_date.strftime('%Y')) worksheet.write(row, col + 3, emp_join_dt, table_border1) else: worksheet.write(row, col + 3, '', table_border1) # SERVICE YEARS if emp_record.joined_year: worksheet.write(row, col + 4, emp_record.joined_year, table_border1) else: worksheet.write(row, col + 4, '', table_border1) # LEAVE STRUCTURE if emp_record.leave_config_id and emp_record.leave_config_id.name: worksheet.write(row, col + 5, emp_record.leave_config_id.name, table_border1) else: worksheet.write(row, col + 5, '', table_border1) # CARRY FORWARD carry_leave = self._get_carry_leave( emp_id, leave_id, fiscalyear_id) if carry_leave and carry_leave[ 0] and carry_leave[0] != None: worksheet.write(row, col + 6, int(carry_leave[0]), table_border1_center) else: worksheet.write(row, col + 6, 0, table_border1_center) # CURRENT YEAR total_leave = self._get_total_leave( emp_id, leave_id, fiscalyear_id) if total_leave != 0: worksheet.write(row, col + 7, int(total_leave), table_border1_center) else: worksheet.write(row, col + 7, 0, table_border1_center) # PENDING pending_leave = self._get_pending_leave( emp_id, leave_id, from_date_str, from_to_str) if pending_leave and pending_leave[ 0] and pending_leave[0] != None: worksheet.write(row, col + 8, pending_leave[0], table_border1_center) else: worksheet.write(row, col + 8, 0, table_border1_center) # TAKEN taken_leave = self._get_taken_leave( emp_id, leave_id, from_date_str, from_to_str) if taken_leave and taken_leave[ 0] and taken_leave[0] != None: worksheet.write(row, col + 9, taken_leave[0], table_border1_center) else: worksheet.write(row, col + 9, 0, table_border1_center) # BALANCE YTD if total_leave != 0: if taken_leave and taken_leave[ 0] and taken_leave[0] != None: after_blc = int(total_leave) - taken_leave[0] worksheet.write(row, col + 10, after_blc or 0, table_border1_center) else: worksheet.write(row, col + 10, total_leave, table_border1_center) else: worksheet.write(row, col + 10, 0, table_border1_center) # BALANCE MTD earn_leaves = self._get_earn_leave(emp_id, leave_id, context["from_date"], context["to_date"], fiscalyear_id) if earn_leaves != 0: if taken_leave and taken_leave[ 0] and taken_leave[0] != None: earn_leaves = earn_leaves - taken_leave[0] worksheet.write(row, col + 11, earn_leaves, table_border1_center) else: worksheet.write(row, col + 11, earn_leaves, table_border1_center) else: worksheet.write(row, col + 11, 0, table_border1_center) row = row + 1 row = row + 1 # WHEN EMPLOYEE CHECKBOX TRUE elif context['all_employee'] == True and context['all_leave'] == False: row = 2 col = 0 self._get_company_info(worksheet, row, header2) row = row + 4 leave_type = str( context["leave_type_id"][1]).upper() + ' LEAVE RECORD' worksheet.row(row).height = 400 worksheet.write_merge(row, row, col, 2, leave_type, header3) worksheet.row(row + 2).height = 500 self._get_employee_header(worksheet, row, table_border) row = row + 3 col = 0 for emp_record in employee_res: emp_id = emp_record.id leave_id = context["leave_type_id"][0] pending_leave = self._get_pending_leave( emp_id, leave_id, from_date_str, from_to_str) taken_leave = self._get_taken_leave(emp_id, leave_id, from_date_str, from_to_str) total_leave = self._get_total_leave(emp_id, leave_id, fiscalyear_id) carry_leave = self._get_carry_leave(emp_id, leave_id, fiscalyear_id) earn_leaves = self._get_earn_leave(emp_id, leave_id, context["from_date"], context["to_date"], fiscalyear_id) # DEPARTMENT if emp_record.department_id and emp_record.department_id.name: worksheet.write(row, col + 0, emp_record.department_id.name, table_border1) else: worksheet.write(row, col + 0, '', table_border1) # IDENTIFICATION NUMBER if emp_record.identification_id: worksheet.write(row, col + 1, emp_record.identification_id, table_border1) else: worksheet.write(row, col + 1, '', table_border1) # EMPLOYEE NAME if emp_record.name: worksheet.write(row, col + 2, emp_record.name, table_border1) else: worksheet.write(row, col + 2, emp_record.name, table_border1) # JOIN DATE if emp_record.join_date: emp_j_date = datetime.strptime(emp_record.join_date, DEFAULT_SERVER_DATE_FORMAT) emp_join_dt = str(emp_j_date.strftime('%d')) + '-' + str( emp_j_date.strftime('%m')) + '-' + str( emp_j_date.strftime('%Y')) worksheet.write(row, col + 3, emp_join_dt, table_border1) else: worksheet.write(row, col + 3, '', table_border1) # SERVICE YEARS if emp_record.joined_year: worksheet.write(row, col + 4, emp_record.joined_year, table_border1) else: worksheet.write(row, col + 4, '', table_border1) # LEAVE STRUCTURE if emp_record.leave_config_id and emp_record.leave_config_id.name: worksheet.write(row, col + 5, emp_record.leave_config_id.name, table_border1) else: worksheet.write(row, col + 5, '', table_border1) # CARRY FORWARD if carry_leave and carry_leave[0] and carry_leave[0] != None: worksheet.write(row, col + 6, int(carry_leave[0]), table_border1_center) else: worksheet.write(row, col + 6, 0, table_border1_center) # CURRENT YEAR TOTAL LEAVE if total_leave != 0: worksheet.write(row, col + 7, int(total_leave), table_border1_center) else: worksheet.write(row, col + 7, 0, table_border1_center) # PENDING if pending_leave and pending_leave[ 0] and pending_leave[0] != None: worksheet.write(row, col + 8, pending_leave[0], table_border1_center) else: worksheet.write(row, col + 8, 0, table_border1_center) # TAKEN if taken_leave and taken_leave[0] and taken_leave[0] != None: worksheet.write(row, col + 9, taken_leave[0], table_border1_center) else: worksheet.write(row, col + 9, 0, table_border1_center) # BALANCE YTD if total_leave != 0: if taken_leave and taken_leave[ 0] and taken_leave[0] != None: after_blc = int(total_leave) - taken_leave[0] worksheet.write(row, col + 10, after_blc or 0, table_border1_center) else: worksheet.write(row, col + 10, total_leave, table_border1_center) else: worksheet.write(row, col + 10, 0, table_border1_center) # BALANCE MTD if earn_leaves != 0: if taken_leave and taken_leave[ 0] and taken_leave[0] != None: earn_leaves = earn_leaves - taken_leave[0] worksheet.write(row, col + 11, earn_leaves, table_border1_center) else: worksheet.write(row, col + 11, earn_leaves, table_border1_center) else: worksheet.write(row, col + 11, 0, table_border1_center) row += 1 row = row + 1 # WHEN LEAVE CHECK BOX IS TRUE elif context['all_leave'] == True and context['all_employee'] == False: row = 2 col = 0 self._get_company_info(worksheet, row, header2) row = row + 4 # worksheet.row(row + 4).height = 500 leave_name = '' if emp_record.leave_config_id and emp_record.leave_config_id.holiday_group_config_line_ids and emp_record.leave_config_id.holiday_group_config_line_ids.ids: leave_ids = [] for leave_config_type in emp_record.leave_config_id.holiday_group_config_line_ids: leave_ids.append(leave_config_type.leave_type_id.id) for leave in leave_obj.browse(leave_ids): row = row + 1 worksheet.row(row).height = 300 worksheet.row(row + 2).height = 500 leave_name = leave.name2 if leave.name2 else leave.name worksheet.write_merge(row, row, col, 2, leave_name, header3) self._get_employee_header(worksheet, row, table_border) row = row + 3 col = 0 emp_id = emp_record.id leave_id = leave.id pending_leave = self._get_pending_leave( emp_id, leave_id, from_date_str, from_to_str) taken_leave = self._get_taken_leave( emp_id, leave_id, from_date_str, from_to_str) total_leave = self._get_total_leave( emp_id, leave_id, fiscalyear_id) carry_leave = self._get_carry_leave( emp_id, leave_id, fiscalyear_id) earn_leaves = self._get_earn_leave(emp_id, leave_id, context["from_date"], context["to_date"], fiscalyear_id) # DEPARTMENT if emp_record.department_id and emp_record.department_id.name: worksheet.write(row, col + 0, emp_record.department_id.name, table_border1) else: worksheet.write(row, col + 0, '', table_border1) # IDENTIFICATION NUMBER if emp_record.identification_id: worksheet.write(row, col + 1, emp_record.identification_id, table_border1) else: worksheet.write(row, col + 1, '', table_border1) if emp_record.name: worksheet.write(row, col + 2, emp_record.name, table_border1) else: worksheet.write(row, col + 2, emp_record.name, table_border1) if emp_record.join_date: emp_j_date = datetime.strptime( emp_record.join_date, DEFAULT_SERVER_DATE_FORMAT) emp_join_dt = str( emp_j_date.strftime('%d')) + '-' + str( emp_j_date.strftime('%m')) + '-' + str( emp_j_date.strftime('%Y')) worksheet.write(row, col + 3, emp_join_dt, table_border1) else: worksheet.write(row, col + 3, '', table_border1) if emp_record.joined_year: worksheet.write(row, col + 4, emp_record.joined_year, table_border1) else: worksheet.write(row, col + 4, '', table_border1) if emp_record.leave_config_id and emp_record.leave_config_id.name: worksheet.write(row, col + 5, emp_record.leave_config_id.name, table_border1) else: worksheet.write(row, col + 5, '', table_border1) # CARRY FORWARD if carry_leave and carry_leave[ 0] and carry_leave[0] != None: worksheet.write(row, col + 6, int(carry_leave[0]), table_border1_center) else: worksheet.write(row, col + 6, 0, table_border1_center) # CURRENT YEAR TOTAL LEAVE if total_leave != 0: worksheet.write(row, col + 7, int(total_leave), table_border1_center) else: worksheet.write(row, col + 7, 0, table_border1_center) # PENDING if pending_leave and pending_leave[ 0] and pending_leave[0] != None: worksheet.write(row, col + 8, pending_leave[0], table_border1_center) else: worksheet.write(row, col + 8, 0, table_border1_center) # TAKEN if taken_leave and taken_leave[ 0] and taken_leave[0] != None: worksheet.write(row, col + 9, taken_leave[0], table_border1_center) else: worksheet.write(row, col + 9, 0, table_border1_center) # BALANCE YTD if total_leave != 0: if taken_leave and taken_leave[ 0] and taken_leave[0] != None: after_blc = int(total_leave) - taken_leave[0] worksheet.write(row, col + 10, after_blc or 0, table_border1_center) else: worksheet.write(row, col + 10, total_leave, table_border1_center) else: worksheet.write(row, col + 10, 0, table_border1_center) # BALANCE MTD if earn_leaves != 0: if taken_leave and taken_leave[ 0] and taken_leave[0] != None: earn_leaves = earn_leaves - taken_leave[0] worksheet.write(row, col + 11, earn_leaves, table_border1_center) else: worksheet.write(row, col + 11, earn_leaves, table_border1_center) else: worksheet.write(row, col + 11, 0, table_border1_center) row += 1 row = row + 1 # WHEN BOTH CHECKBOX IS FALSE else: row = 2 col = 0 self._get_company_info(worksheet, row, header2) row = row + 5 worksheet.row(row).height = 340 worksheet.write_merge(row, row, col, 2, context["leave_type_id"][1], header3) worksheet.row(row + 2).height = 500 self._get_employee_header(worksheet, row, table_border) row = row + 3 col = 0 emp_id = emp_record.id leave_id = context["leave_type_id"][0] pending_leave = self._get_pending_leave(emp_id, leave_id, from_date_str, from_to_str) taken_leave = self._get_taken_leave(emp_id, leave_id, from_date_str, from_to_str) total_leave = self._get_total_leave(emp_id, leave_id, fiscalyear_id) carry_leave = self._get_carry_leave(emp_id, leave_id, fiscalyear_id) earn_leaves = self._get_earn_leave(emp_id, leave_id, context["from_date"], context["to_date"], fiscalyear_id) # DEPARTMENT if emp_record.department_id and emp_record.department_id.name: worksheet.write(row, col + 0, emp_record.department_id.name, table_border1) else: worksheet.write(row, col + 0, '', table_border1) # IDENTIFICATION NUMBER if emp_record.identification_id: worksheet.write(row, col + 1, emp_record.identification_id, table_border1) else: worksheet.write(row, col + 1, '', table_border1) # EMPLOYEE NAME if emp_record.name: worksheet.write(row, col + 2, emp_record.name, table_border1) else: worksheet.write(row, col + 2, emp_record.name, table_border1) # DATE JOINED if emp_record.join_date: emp_j_date = datetime.strptime(emp_record.join_date, DEFAULT_SERVER_DATE_FORMAT) emp_join_dt = str(emp_j_date.strftime('%d')) + '-' + str( emp_j_date.strftime('%m')) + '-' + str( emp_j_date.strftime('%Y')) worksheet.write(row, col + 3, emp_join_dt, table_border1) else: worksheet.write(row, col + 3, '', table_border1) # SERVICE YEARS if emp_record.joined_year: worksheet.write(row, col + 4, emp_record.joined_year, table_border1) else: worksheet.write(row, col + 4, '', table_border1) # LEAVE STRUCTURE if emp_record.leave_config_id and emp_record.leave_config_id.name: worksheet.write(row, col + 5, emp_record.leave_config_id.name, table_border1) else: worksheet.write(row, col + 5, '', table_border1) # CARRY FORWARD if carry_leave and carry_leave[0] and carry_leave[0] != None: worksheet.write(row, col + 6, int(carry_leave[0]), table_border1_center) else: worksheet.write(row, col + 6, 0, table_border1_center) # CURRENT YEAR if total_leave != 0: worksheet.write(row, col + 7, int(total_leave), table_border1_center) else: worksheet.write(row, col + 7, 0, table_border1_center) # PENDING if pending_leave and pending_leave[0] and pending_leave[0] != None: worksheet.write(row, col + 8, pending_leave[0], table_border1_center) else: worksheet.write(row, col + 8, 0, table_border1_center) # TAKEN if taken_leave and taken_leave[0] and taken_leave[0] != None: worksheet.write(row, col + 9, taken_leave[0], table_border1_center) else: worksheet.write(row, col + 9, 0, table_border1_center) # BALANCE YTD if total_leave != 0: if taken_leave and taken_leave[0] and taken_leave[0] != None: after_blc = int(total_leave) - taken_leave[0] worksheet.write(row, col + 10, after_blc or 0, table_border1_center) else: worksheet.write(row, col + 10, total_leave, table_border1_center) else: worksheet.write(row, col + 10, 0, table_border1_center) # BALANCE MTD if earn_leaves != 0: if taken_leave and taken_leave[0] and taken_leave[0] != None: earn_leaves = earn_leaves - taken_leave[0] worksheet.write(row, col + 11, earn_leaves, table_border1_center) else: worksheet.write(row, col + 11, earn_leaves, table_border1_center) else: worksheet.write(row, col + 11, 0, table_border1_center) row += 1 row = row + 1 fp = StringIO() workbook.save(fp) fp.seek(0) data = fp.read() fp.close() res = base64.encodestring(data) module_rec = self.env['excel.sg.leave.summary.report'].create({ 'name': 'Leave summary.xls', 'file': res }) return { 'name': _('Leave Summary Report'), 'res_id': module_rec.id, 'view_type': 'form', "view_mode": 'form', 'res_model': 'excel.sg.leave.summary.report', 'type': 'ir.actions.act_window', 'target': 'new', 'context': context, }
def export_query(): """export from report builder""" form_params = get_form_params() form_params["limit_page_length"] = None form_params["as_list"] = True doctype = form_params.doctype add_totals_row = None file_format_type = form_params["file_format_type"] del form_params["doctype"] del form_params["file_format_type"] if 'add_totals_row' in form_params and form_params['add_totals_row'] == '1': add_totals_row = 1 del form_params["add_totals_row"] frappe.permissions.can_export(doctype, raise_exception=True) if 'selected_items' in form_params: si = json.loads(frappe.form_dict.get('selected_items')) form_params["filters"] = {"name": ("in", si)} del form_params["selected_items"] db_query = DatabaseQuery(doctype) ret = db_query.execute(**form_params) if add_totals_row: ret = append_totals_row(ret) data = [['Sr'] + get_labels(db_query.fields, doctype)] for i, row in enumerate(ret): data.append([i + 1] + list(row)) if file_format_type == "CSV": # convert to csv import csv from cStringIO import StringIO f = StringIO() writer = csv.writer(f) for r in data: # encode only unicode type strings and not int, floats etc. writer.writerow( map( lambda v: isinstance(v, unicode) and v.encode('utf-8') or v, r)) f.seek(0) frappe.response['result'] = unicode(f.read(), 'utf-8') frappe.response['type'] = 'csv' frappe.response['doctype'] = doctype elif file_format_type == "Excel": from frappe.utils.xlsxutils import make_xlsx xlsx_file = make_xlsx(data, doctype) frappe.response['filename'] = doctype + '.xlsx' frappe.response['filecontent'] = xlsx_file.getvalue() frappe.response['type'] = 'binary'
class PDFContentParser(PSStackParser): def __init__(self, streams): self.streams = streams self.istream = 0 PSStackParser.__init__(self, None) return def fillfp(self): if not self.fp: if self.istream < len(self.streams): strm = stream_value(self.streams[self.istream]) self.istream += 1 else: raise PSEOF('Unexpected EOF, file truncated?') self.fp = StringIO(strm.get_data()) return def seek(self, pos): self.fillfp() PSStackParser.seek(self, pos) return def fillbuf(self): if self.charpos < len(self.buf): return while 1: self.fillfp() self.bufpos = self.fp.tell() self.buf = self.fp.read(self.BUFSIZ) if self.buf: break self.fp = None self.charpos = 0 return def get_inline_data(self, pos, target='EI'): self.seek(pos) i = 0 data = '' while i <= len(target): self.fillbuf() if i: c = self.buf[self.charpos] data += c self.charpos += 1 if len(target) <= i and c.isspace(): i += 1 elif i < len(target) and c == target[i]: i += 1 else: i = 0 else: try: j = self.buf.index(target[0], self.charpos) #print 'found', (0, self.buf[j:j+10]) data += self.buf[self.charpos:j+1] self.charpos = j+1 i = 1 except ValueError: data += self.buf[self.charpos:] self.charpos = len(self.buf) data = data[:-(len(target)+1)] # strip the last part data = re.sub(r'(\x0d\x0a|[\x0d\x0a])', '', data) return (pos, data) def flush(self): self.add_results(*self.popall()) return KEYWORD_BI = PSKeywordTable.intern('BI') KEYWORD_ID = PSKeywordTable.intern('ID') KEYWORD_EI = PSKeywordTable.intern('EI') def do_keyword(self, pos, token): if token is self.KEYWORD_BI: # inline image within a content stream self.start_type(pos, 'inline') elif token is self.KEYWORD_ID: try: (_, objs) = self.end_type('inline') if len(objs) % 2 != 0: raise PSTypeError('Invalid dictionary construct: %r' % objs) d = dict( (literal_name(k), v) for (k,v) in choplist(2, objs) ) (pos, data) = self.get_inline_data(pos+len('ID ')) obj = PDFStream(d, data) self.push((pos, obj)) self.push((pos, self.KEYWORD_EI)) except PSTypeError: if STRICT: raise else: self.push((pos, token)) return
class TZlibTransport(TTransportBase, CReadableTransport): ''' Class that wraps a transport with zlib, compressing writes and decompresses reads, using the python standard library zlib module. ''' # Read buffer size for the python fastbinary C extension, # the TBinaryProtocolAccelerated class. DEFAULT_BUFFSIZE = 4096 def __init__(self, trans, compresslevel=9): ''' Create a new TZlibTransport, wrapping C{trans}, another TTransport derived object. @param trans: A thrift transport object, i.e. a TSocket() object. @type trans: TTransport @param compresslevel: The zlib compression level, ranging from 0 (no compression) to 9 (best compression). Default is 9. @type compresslevel: int ''' self.__trans = trans self.compresslevel = compresslevel self.__rbuf = StringIO() self.__wbuf = StringIO() self._init_zlib() self._init_stats() def _reinit_buffers(self): ''' Internal method to initialize/reset the internal StringIO objects for read and write buffers. ''' self.__rbuf = StringIO() self.__wbuf = StringIO() def _init_stats(self): ''' Internal method to reset the internal statistics counters for compression ratios and bandwidth savings. ''' self.bytes_in = 0 self.bytes_out = 0 self.bytes_in_comp = 0 self.bytes_out_comp = 0 def _init_zlib(self): ''' Internal method for setting up the zlib compression and decompression objects. ''' self._zcomp_read = zlib.decompressobj() self._zcomp_write = zlib.compressobj(self.compresslevel) def getCompRatio(self): ''' Get the current measured compression ratios (in,out) from this transport. Returns a tuple of: (inbound_compression_ratio, outbound_compression_ratio) The compression ratios are computed as: compressed / uncompressed E.g., data that compresses by 10x will have a ratio of: 0.10 and data that compresses to half of ts original size will have a ratio of 0.5 None is returned if no bytes have yet been processed in a particular direction. ''' r_percent, w_percent = (None, None) if self.bytes_in > 0: r_percent = self.bytes_in_comp / self.bytes_in if self.bytes_out > 0: w_percent = self.bytes_out_comp / self.bytes_out return (r_percent, w_percent) def getCompSavings(self): ''' Get the current count of saved bytes due to data compression. Returns a tuple of: (inbound_saved_bytes, outbound_saved_bytes) Note: if compression is actually expanding your data (only likely with very tiny thrift objects), then the values returned will be negative. ''' r_saved = self.bytes_in - self.bytes_in_comp w_saved = self.bytes_out - self.bytes_out_comp return (r_saved, w_saved) def isOpen(self): '''Return the underlying transport's open status''' return self.__trans.isOpen() def open(self): """Open the underlying transport""" self._init_stats() return self.__trans.open() def listen(self): '''Invoke the underlying transport's listen() method''' self.__trans.listen() def accept(self): '''Accept connections on the underlying transport''' return self.__trans.accept() def close(self): '''Close the underlying transport,''' self._reinit_buffers() self._init_zlib() return self.__trans.close() def read(self, sz): ''' Read up to sz bytes from the decompressed bytes buffer, and read from the underlying transport if the decompression buffer is empty. ''' ret = self.__rbuf.read(sz) if len(ret) > 0: return ret # keep reading from transport until something comes back while True: if self.readComp(sz): break ret = self.__rbuf.read(sz) return ret def readComp(self, sz): ''' Read compressed data from the underlying transport, then decompress it and append it to the internal StringIO read buffer ''' zbuf = self.__trans.read(sz) zbuf = self._zcomp_read.unconsumed_tail + zbuf buf = self._zcomp_read.decompress(zbuf) self.bytes_in += len(zbuf) self.bytes_in_comp += len(buf) old = self.__rbuf.read() self.__rbuf = StringIO(old + buf) if len(old) + len(buf) == 0: return False return True def write(self, buf): ''' Write some bytes, putting them into the internal write buffer for eventual compression. ''' self.__wbuf.write(buf) def flush(self): ''' Flush any queued up data in the write buffer and ensure the compression buffer is flushed out to the underlying transport ''' wout = self.__wbuf.getvalue() if len(wout) > 0: zbuf = self._zcomp_write.compress(wout) self.bytes_out += len(wout) self.bytes_out_comp += len(zbuf) else: zbuf = '' ztail = self._zcomp_write.flush(zlib.Z_SYNC_FLUSH) self.bytes_out_comp += len(ztail) if (len(zbuf) + len(ztail)) > 0: self.__wbuf = StringIO() self.__trans.write(zbuf + ztail) self.__trans.flush() @property def cstringio_buf(self): '''Implement the CReadableTransport interface''' return self.__rbuf def cstringio_refill(self, partialread, reqlen): '''Implement the CReadableTransport interface for refill''' retstring = partialread if reqlen < self.DEFAULT_BUFFSIZE: retstring += self.read(self.DEFAULT_BUFFSIZE) while len(retstring) < reqlen: retstring += self.read(reqlen - len(retstring)) self.__rbuf = StringIO(retstring) return self.__rbuf
def callable(self, base_url, dir, root="", handlers=None, server_admin=None): """ Verwandelt CherryPy in einen CGI-Server :param base_url: Absolute HTTP-URL of the CGI base directory. z.B.: "/cgi" :param dir: Absoluter oder relativer Pfad zum Ordner mit den CGI-Dateien. Wird der Pfad relativ angegeben, dann wird er an *root* angehängt. Gleiches Verhalten wie beim Staticdir-Tool. :param root: An diesen Pfad wird *dir* angehängt, falls *dir* nicht absolut übergeben wurde. :param handlers: Dictionary mit den Dateiendungen und den zugehörigen Interpretern. z.B.:: {".php": "/usr/bin/php-cgi", ".py": "/usr/bin/python"} Es werden nur Dateien ausgeführt, denen ein Handler zugewiesen wurde. Wird die Dateiendung nicht im Dictionary gefunden, wird das Tool beendet, so dass die Abarbeitung des Requests z.B. von Staticdir ausgeliefert werden kann. :param server_admin: Enthält Namen/E-Mail-Adresse des Server-Administrators. Diese Information wird über die Umgebungsvariable SERVER_ADMIN an das CGI-Programm übergeben. """ # short names for request and headers request = cherrypy.request headers = request.headers # Allow the use of '~' to refer to a user's home directory. # (copied from *cherrypy.lib.static*) dir = os.path.expanduser(dir) # If dir is relative, make absolute using "root". # (copied from *cherrypy.lib.static*) if not os.path.isabs(dir): if not root: msg = "Static dir requires an absolute dir (or root)." cherrypy.log(msg, 'TOOLS.CGISERVER') raise ValueError(msg) dir = os.path.join(root, dir) # Determine where we are in the object tree relative to 'base_url' # (copied from *cherrypy.lib.static*) if base_url == "": base_url = "/" base_url = base_url.rstrip(r"\/") branch = request.path_info[len(base_url) + 1:] branch = unquote(branch.lstrip(r"\/")) # Dateiname des Skriptes ermitteln (Es muss auf angehängte Pfade geachtet werden.) # Dabei wird auch der an die URL des Skriptes angehängte Pfad ermittelt branch_items = branch.split("/") script_filename = None path_info_start = None path_info = "" for i in range(len(branch_items), 0, -1): _file_path = os.path.join(dir, *branch_items[:i]) if os.path.isfile(_file_path): script_filename = _file_path path_info_start = i break if not path_info_start is None and branch_items[path_info_start:]: path_info = "/" + "/".join(branch_items[path_info_start:]) if not script_filename: return # URL des Skriptes ermitteln script_name = script_filename[len(dir):] # There's a chance that the branch pulled from the URL might # have ".." or similar uplevel attacks in it. Check that the final # filename is a child of dir. # (copied from *cherrypy.lib.static*) if not os.path.normpath(script_filename).startswith( os.path.normpath(dir)): raise cherrypy.HTTPError(403) # Forbidden # Wenn Dateiendung unbekannt, dann Funktion beenden, damit ein # evt. eingestelltes Staticdir-Tool die Datei ausliefern kann ext = os.path.splitext(script_filename)[1] if ext not in handlers: return # Interpreter anhand der Dateiendung ermitteln handler_executable = handlers[ext] # # TEST --------- # cherrypy.serving.response.body = [show_request()] # cherrypy.serving.request.handler = None # return # # TEST ---------- # prepare body if request.method in request.methods_with_bodies: body_file = request.rfile content_length = headers.get("content-length", 0) else: body_file = StringIO() content_length = None # prepare environment for CGI callable # There I got infos about the environment variables: # http://de.selfhtml.org/servercgi/cgi/umgebungsvariablen.htm # http://tools.ietf.org/html/rfc3875#page-12 env = { # GATEWAY_INTERFACE # Enthält die Version der CGI-Schnittstelle, die von dem installierten # Server unterstützt wird, z.B. CGI/1.1, wenn die gegenwärtig übliche # Version 1.1 der Schnittstellendefinition unterstützt wird. "GATEWAY_INTERFACE": "CGI/1.1", # SERVER_SIGNATURE # Enthält eine erweiterte Selbstauskunft des Servers, # z.B. Apache/1.3.31 Server at localhost Port 80. "SERVER_SIGNATURE": "CherryPy CgiServer", # REMOTE_ADDR # Enthält die IP-Adresse des Server-Rechners, über den das CGI-Script # aufgerufen wurde. Es muss sich hierbei nicht unbedingt um die # IP-Adresse des aufrufenden Client-Rechners handeln - der Wert kann # beispielsweise auch von einem Proxy-Server stammen. "REMOTE_ADDR": request.remote.ip, # REMOTE_PORT # Ermittelt, über welchen Port des Client-Rechners das CGI-Script # aufgerufen wurde. Diese Zahl liegt gewöhnlich im Bereich ab 1024 # aufwärts und wird vom aufrufenden Web-Browser zufällig ausgewählt. "REMOTE_PORT": str(request.remote.port), # SERVER_ADDR # Enthält die IP-Adresse des Server-Rechners. "SERVER_ADDR": request.local.ip, # SERVER_PORT # Enthält die Portnummer, die für den Webserver eingerichtet wurde. # Normalerweise ist dies für Webserver die Nummer 80. "SERVER_PORT": str(request.local.port), # DOCUMENT_ROOT # Enthält den physischen Pfad des Wurzelverzeichnisses für die Ablage # von Dateien, die im Webserver aufrufbar sind. Ein CGI-Script kann aus # dieser Angabe beispielsweise absolute Pfadnamen zum Öffnen von Dateien # errechnen. "DOCUMENT_ROOT": dir, # PATH_INFO # Wird einem CGI-Script eine Zeichenkette mit Daten übergeben, # dann enthält PATH_INFO den Teil der Zeichenkette nach dem Namen # des Scripts bis zum ersten ?. Wenn das Script beispielsweise die # Adresse http://meine.seite.net/cgi-bin/test.pl hat, aber mit # http://meine.seite.net/cgi-bin/test.pl/querys/musicbase.sql?cat=Mozart # aufgerufen wird, dann enthält diese Umgebungsvariable den Anteil # /querys/musicbase.sql. Sie ist dazu gedacht, Dateinamen mit Pfadangabe # als Übergabeparameter für Scripts zu ermöglichen. "PATH_INFO": path_info, # PATH_TRANSLATED # Enthält wie PATH_INFO den Anteil des URI nach dem Scriptnamen bis # zum ersten ?, jedoch mit dem Unterschied, dass nicht der Anteil # selbst aus dem URI zurückgegeben wird, sondern der vom Webserver # übersetzte Datenpfad dieses Anteils. Angenommen, das Script hat die # Adresse http://meine.seite.net/cgi-bin/test.pl, wurde aber mit # http://meine.seite.net/cgi-bin/test.pl/querys/musicbase.sql aufgerufen. # Dann könnte der zusätzliche Adressanteil /querys/musicbase.sql aus # Sicht des Webservers beispielsweise in einen physischen Pfadnamen wie # /usr/web/seite/querys/musicbase.sql aufgelöst werden. Diesen Pfadnamen # würde PATH_TRANSLATED zurückgeben. "PATH_TRANSLATED": dir.rstrip("/") + path_info if path_info else "", # SCRIPT_FILENAME # Enthält den physischen Pfad des Scripts auf dem Server-Rechner, # also z.B. /usr/web/data/cgi-bin/test.pl. "SCRIPT_FILENAME": script_filename, # SCRIPT_NAME # Enthält den HTTP-Pfad des Scripts. Angenommen, das Script hat die # Adresse http://meine.seite.net/cgi-bin/test.pl. Dann liefert # SCRIPT_NAME den Wert /cgi-bin/test.pl. "SCRIPT_NAME": script_name, } # REMOTE_HOST # Enthält den Hostnamen des Rechners, über den das CGI-Script aufgerufen # wurde. Dieser Wert wird jedoch nur gesetzt, wenn der Webserver # entsprechend konfiguriert und dazu in der Lage ist, der IP-Adresse # den entsprechenden Hostnamen zuzuordnen. Es muss sich hierbei nicht # unbedingt um die IP-Adresse des aufrufenden Client-Rechners handeln - # der Wert kann beispielsweise auch von einem Proxy-Server stammen. if request.remote.name: env["REMOTE_HOST"] = request.remote.name # SERVER_NAME # Enthält den Namen des Server-Rechners, auf dem das CGI-Script läuft. # Normalerweise ist dies der eingetragene Hostname des Rechners. if request.local.name: env["SERVER_NAME"] = request.local.name # CONTENT_LENGTH # Enthält die Anzahl der Zeichen, die beim Aufruf des CGI-Scripts # über die POST-Methode übergeben wurden. Wenn das CGI-Script # beispielsweise beim Absenden eines HTML-Formulars aufgerufen # wurde und dort als Übertragungsmethode POST angegeben ist, # steht in dieser Umgebungsvariablen, wie viele Zeichen das Script # von der Standardeingabe lesen muss, um die übermittelten # Formulardaten vollständig einzulesen. if not content_length is None: env["CONTENT_LENGTH"] = str(content_length) # CONTENT_TYPE # Enthält beim Aufruf über die POST-Methode den Seite MIME-Typ # der übergebenen Daten. Wenn das CGI-Script beispielsweise beim # Absenden eines HTML-Formulars aufgerufen wurde und dort als # Übertragungsmethode POST angegeben ist, steht in dieser # Umgebungsvariablen der für HTML-Formulare typische MIME-Typ # application/x-www-form-urlencoded (zu diesem MIME-Typ siehe auch # Seite Datenstrom bei Übertragung von Formulardaten). if "content-type" in headers: env["CONTENT_TYPE"] = headers["CONTENT_TYPE"] # HTTP_ACCEPT # Enthält die Liste der MIME-Typen, die der aufrufende Web-Browser # akzeptiert. Die Angabe */* bedeutet: der Web-Browser akzeptiert alles. if "accept" in headers: env["HTTP_ACCEPT"] = headers["accept"] elif hasattr(request, "wsgi_environ"): if "HTTP_ACCEPT" in request.wsgi_environ: env["HTTP_ACCEPT"] = request.wsgi_environ["HTTP_ACCEPT"] # HTTP_ACCEPT_CHARSET # Enthält die Liste der Zeichenkodierungen, die der aufrufende Web-Browser # akzeptiert, beispielsweise iso-8859-1, utf-8, utf-16, *;q=0.1. if "accept-charset" in headers: env["HTTP_ACCEPT_CHARSET"] = headers["accept-charset"] # HTTP_ACCEPT_ENCODING # Enthält eine Liste der Kodierungsmethoden, die der aufrufende Browser # akzeptiert. Manche Browser akzeptieren beispielsweise auch den # Kodierungstyp gzip, was bedeutet, dass der Browser auch Dateien # empfangen kann, die nach dem GNU-Zip-Algorithmus komprimiert an ihn # übertragen werden. if "accept-encoding" in headers: env["HTTP_ACCEPT_ENCODING"] = headers["accept-encoding"] elif hasattr(request, "wsgi_environ"): if "HTTP_ACCEPT_ENCODING" in request.wsgi_environ: env["HTTP_ACCEPT_ENCODING"] = request.wsgi_environ[ "HTTP_ACCEPT_ENCODING"] # HTTP_ACCEPT_LANGUAGE # Enthält, welche Landessprache der aufrufende Browser bei seiner # Benutzeroberfläche verwendet. Häufige Werte sind z.B. de (für # deutschsprachige Browser) oder en (für englischsprachige Browser). # Ein CGI-Script kann aufgrund dieser Angabe beispielsweise entscheiden, # ob es eine deutschsprachige oder eine englischsprachige Antwort an # den Browser sendet. if "accept-language" in headers: env["HTTP_ACCEPT_LANGUAGE"] = headers["accept-language"] # HTTP_CONNECTION # Enthält Informationen über den Status der HTTP-Verbindung zwischen # Server und aufrufendem Browser. Der Wert Keep-Alive bedeutet, der # Browser wartet auf Antwort. if "connection" in headers: env["HTTP_CONNECTION"] = headers["connection"] elif hasattr(request, "wsgi_environ"): if "HTTP_CONNECTION" in request.wsgi_environ: env["HTTP_CONNECTION"] = request.wsgi_environ[ "HTTP_CONNECTION"] # HTTP_COOKIE # Enthält Namen und Wert von Cookies, sofern solche vom aufrufenden # Browser gesendet werden. if request.cookie: env["HTTP_COOKIE"] = request.cookie # HTTP_HOST # Enthält den Domain-Namen oder die IP-Adresse aus der Adresszeile des # aufrufenden Browsers. Für ein CGI-Script kann diese Angabe wichtig sein, # falls es mehrere Server bedienen muss. if "host" in headers: env["HTTP_HOST"] = headers["host"] elif hasattr(request, "wsgi_environ"): if "HTTP_HOST" in request.wsgi_environ: env["HTTP_HOST"] = request.wsgi_environ["HTTP_HOST"] # HTTP_REFERER # Enthält den URI der Web-Seite, von der aus das CGI-Script aufgerufen # wurde. Der Wert wird jedoch nicht von allen Web-Browsern korrekt # übermittelt, ist also nicht in jedem Fall verfügbar. if "referer" in headers: env["HTTP_REFERER"] = headers["referer"] # HTTP_USER_AGENT # Enthält Produkt- und Versionsinformationen zum aufrufenden Web-Browser. # Ein CGI-Script kann auf diese Weise ermitteln, welchen Browser ein # Anwender verwendet. if "user-agent" in headers: env["HTTP_USER_AGENT"] = headers["user-agent"] # QUERY_STRING # Enthält eine Zeichenkette mit Daten, die dem Script im URI nach dem # ersten ? übergeben wurden. Angenommen, das Script hat die Adresse # http://meine.seite.net/cgi-bin/test.pl, wurde aber mit # http://meine.seite.net/cgi-bin/test.pl?User=Stefan aufgerufen. # Dann würde QUERY_STRING den Wert User=Stefan enthalten. Wenn ein # Anwender ein HTML-Formular ausgefüllt hat, bei dessen Absenden das # CGI-Script mit der GET-Methode aufgerufen wurde, dann stehen in # dieser Umgebungsvariablen die ausgefüllten Formulardaten. Die Daten # sind nach den Regeln des MIME-Typs application/x-www-form-urlencoded # kodiert. if hasattr(request, "query_string"): env["QUERY_STRING"] = request.query_string elif hasattr(request, "wsgi_environ"): if "QUERY_STRING" in request.wsgi_environ: env["QUERY_STRING"] = request.wsgi_environ["QUERY_STRING"] # REMOTE_IDENT # Enthält Protokollinformationen, wenn auf dem Server das Protokoll # ident für geschützte Zugriffe läuft. # REMOTE_USER # Enthält den Benutzernamen, mit dem sich der aufrufende Benutzer # angemeldet hat, um das CGI-Script ausführen zu lassen. Wenn das # Script beispielsweise htaccess-geschützt ist, muss sich der # aufrufende Benutzer mit Benutzernamen und Passwort anmelden. Der # dabei eingegebene Benutzername kann mit dieser Variable ermittelt # werden. if hasattr(request, "login"): if request.login and not request.login.lower() == "none": env["REMOTE_USER"] = request.login # REQUEST_METHOD # Enthält die HTTP-Anfragemethode, mit der das CGI-Programm aufgerufen # wurde. Beispielsweise GET oder POST. Ein CGI-Script kann diese # Variable auslesen und danach entscheiden, wie es Formulardaten # einlesen kann: entweder von der Standardeingabe (bei Methode POST) # oder aus der Umgebungsvariablen QUERY_STRING (bei Methode GET). if hasattr(request, "method"): env["REQUEST_METHOD"] = request.method # REQUEST_URI # Enthält den HTTP-Pfad des Scripts inklusive der im Aufruf übergebenen # Daten. Angenommen, das Script hat die Adresse # http://meine.seite.net/cgi-bin/test.pl und wurde mit # http://meine.seite.net/cgi-bin/test.pl?User=Stefan aufgerufen. # Dann liefert REQUEST_URI den Wert /cgi-bin/test.pl?User=Stefan. elif hasattr(request, "wsgi_environ"): if "REQUEST_URI" in request.wsgi_environ: env["REQUEST_URI"] = request.wsgi_environ["REQUEST_URI"] # SERVER_ADMIN # Enthält Namen/E-Mail-Adresse des in der Webserver-Konfiguration # eingetragenen Server-Administrators. if server_admin: env["SERVER_ADMIN"] = server_admin # SERVER_PROTOCOL # Enthält die Version des HTTP-Protokolls, das der installierte # Webserver unterstützt, z.B. HTTP/1.1, wenn die gegenwärtig übliche # Version 1.1 des HTTP-Protokolls unterstützt wird. if hasattr(request, "server_protocol"): env["SERVER_PROTOCOL"] = request.server_protocol # SERVER_SOFTWARE # Enthält den Namen und die Versionsnummer der Webserver-Software auf # dem Server-Rechner. if hasattr(request, "wsgi_environ"): if "SERVER_SOFTWARE" in request.wsgi_environ: env["SERVER_SOFTWARE"] = request.wsgi_environ[ "SERVER_SOFTWARE"] env["REDIRECT_STATUS"] = "200" # call interpreter cmd_args = [handler_executable, script_filename] proc = subprocess.Popen(cmd_args, executable=handler_executable, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=dir, env=env) proc.stdin.write(body_file.read()) # get headers cherrypy.serving.response.headers = wsgiserver2.read_headers( proc.stdout, cherrypy.serving.response.headers) # get body cherrypy.serving.response.body = proc.stdout # finished: no more request handler needed cherrypy.serving.request.handler = None
#! /us/bin/env/python # -*- coding:utf-8 -*- # Find the best implementation available on this platform try: from cStringIO import StringIO except: from StringIO import StringIO # Writing to a buffer output = StringIO() output.write('This goes into the buffer.') print >> output, 'And so does this.' # Retrieve the value written print output.getvalue() output.close() #discard buffer memory # Initialize a read buffer input = StringIO('Inital value for read buffer') # Read from the buffer print input.read()
class SocketFile(object): """ File-like wrapper for reading socket objects. """ def __init__(self, socket, encoding=None): super(SocketFile, self).__init__() self._socket = socket self._buffer = BytesIO() self.encoding = encoding def _append_buffer(self, data): pos = self._buffer.tell() self._buffer.seek(0, 2) self._buffer.write(data) self._buffer.seek(pos) def bind(self, *args, **kwargs): return self._socket.bind(*args, **kwargs) def connect(self, *args, **kwargs): return self._socket.connect(*args, **kwargs) def read(self, length, blocking=True): data = self._buffer.read(length) delta = length - len(data) if delta > 0: self._socket.setblocking(blocking) try: data += self._socket.recv(delta) except socket.error: pass return data def readline(self): parts = [] while True: # Read the waiting data from the socket. data = self.read(1024, blocking=False) # If it contains a line-feed character, we add it # to the result list and append the rest of the data # to the buffer. if b'\n' in data: left, right = data.split(b'\n', 1) parts.append(left + b'\n') self._append_buffer(right) break else: if data: parts.append(data) # Read a blocking byte for which we will get an empty # bytes object if the socket is closed- byte = self.read(1, blocking=True) if not byte: break # Add the byte to the buffer. Stop here if it is a # newline character. parts.append(byte) if byte == b'\n': break return b''.join(parts) def write(self, data): if isinstance(data, str): if not self.encoding: raise ValueError('got str object and no encoding specified') data = data.encode(self.encoding) return self._socket.send(data) def close(self): return self._socket.close()
def parsetx(self, txdata, txcount): ''' Parse Tx data to get version, hashes, etc. :param txdata: :return: ''' txinfo = [] utility = Util() scripts = script.Script() ''' [---TX_PAYLOAD---] [ 4] VERSION <I uint32_t [..] TX_IN_COUNT variable integer [..] TX_IN multiple of TX_IN_COUNT [32] PREV_OUT_HASH char[32] [ 4] PREV_OUT_INDEX <I (zero-based) uint32_t [..] SCRIPT_LENGTH variable integer [..] SCRIPT variable string [ 4] SEQUENCE <I uint32_t [..] TX_OUT_COUNT variable integer [..] TX_OUT multiple of TX_OUT_COUNT [ 8] VALUE <q int64_t [..] SCRIPT_LENGTH variable integer [..] SCRIPT variable string [ 4] LOCK_TIME <I uint32_t ''' decodeData = StringIO(txdata) # Get length of data, then reset to start decodeData.seek(0, os.SEEK_END) txdatalen = decodeData.tell() decodeData.seek(0) logger.info('Tx Data Length: {}'.format(txdatalen)) # Loop through each transaction for txnum in range(1, txcount + 1): txdetails = {} logger.debug('Processing Tx # {}'.format(txnum)) txdetails['version'] = struct.unpack('<I', decodeData.read(4))[0] txdetails['tx_in_count'] = utility.deserialize_int(decodeData)[0] txdetails['Number'] = txnum # Loop through each input logger.debug('Tx In Count: {}'.format(txdetails['tx_in_count'])) for tx_input in range(txdetails['tx_in_count']): logger.debug('Tx In {}'.format(tx_input)) logger.debug('Remaining length: {}'.format(txdatalen - decodeData.tell())) txdetails['input_prev_hash_{}'.format(tx_input)] = hexlify( decodeData.read(32)[::-1]) txdetails['input_prev_index_{}'.format( tx_input)] = struct.unpack('<I', decodeData.read(4))[0] txdetails['input_script_length_{}'.format( tx_input)] = utility.deserialize_int(decodeData)[0] txdetails['input_script_{}'.format(tx_input)] = hexlify( decodeData.read( txdetails['input_script_length_{}'.format(tx_input)])) # Parse input script scripts.parsetxinputscript(txnum, tx_input, txinfo, txdetails) #self.parsetxinputscript(txnum, tx_input, txinfo, txdetails) txdetails['input_sequence_{}'.format( tx_input)] = struct.unpack('<I', decodeData.read(4))[0] txdetails['tx_out_count'] = utility.deserialize_int(decodeData)[0] # Loop through each output logger.debug('Tx Out Count: {}'.format(txdetails['tx_out_count'])) for tx_output in range(txdetails['tx_out_count']): txdetails['output_value_{}'.format(tx_output)] = struct.unpack( '<q', decodeData.read(8))[0] # In Satoshis txdetails['output_value_{}'.format(tx_output)] = ( txdetails['output_value_{}'.format(tx_output)] / 10**8 ) #value = (value / 10**8) txdetails['output_script_length_{}'.format( tx_output)] = utility.deserialize_int(decodeData)[0] txdetails['output_script_{}'.format(tx_output)] = hexlify( decodeData.read(txdetails['output_script_length_{}'.format( tx_output)])) # Parse out Opcodes, etc scripts.parsetxoutputscript(txnum, tx_output, txinfo, txdetails) txdetails['lock_time'] = struct.unpack('<I', decodeData.read(4))[0] txinfo.append(txdetails) #logger.info(pprint.pformat(txinfo)) return txinfo
def export_data(): engine = create_engine(connection_string) cur = engine.connect() all_questions = cur.execute("select question from questions") all_answers = cur.execute( "select choice from questions_choices where is_right = true") quest_set = [] ans_set = [] for each_quest in all_questions: quest_set.append(each_quest[0]) for each_ans in all_answers: ans_set.append(each_ans[0]) quest_ans_set = zip(quest_set, ans_set) if current_user.is_admin and request.form['selected_report_type'] == 'XLS': file_data = StringIO() workbook = xlsxwriter.Workbook(file_data) worksheet = workbook.add_worksheet('Data') # Add a bold format to use to highlight cells. bold = workbook.add_format({'bold': True}) worksheet.write('A1', 'Question', bold) # Start from the first cell. Rows and columns are zero indexed. row = 1 col = 0 for each_q_ans in quest_ans_set: worksheet.write(row, col, each_q_ans[0]) row += 1 worksheet.write(row, col, 'Ans: ' + each_q_ans[1]) row += 1 workbook.close() file_data.seek(0) return Response(file_data.read(), mimetype="application/excel", headers={ "Content-disposition": "attachment; filename=Question Report.xls" }) # elif current_user.is_admin and request.form['selected_report_type'] == 'DOC': # file_data = StringIO() # document = Document() # document.add_heading('Question Set', level=1) # document.add_paragraph([str(ques_ans[0]) + '\n' + 'Ans: ' + str(ques_ans[1]) + # '\n' for ques_ans in quest_ans_set]) # document.save(file_data) # file_data.seek(0) # return Response( # file_data.read(), # mimetype="application/doc", # headers={"Content-disposition": "attachment; filename=Question Report.doc"}) elif current_user.is_admin and request.form[ 'selected_report_type'] == 'PDF': file_data = StringIO() p = canvas.Canvas(file_data, pagesize=A4) p.setFont('Helvetica', 14) p.drawString(250, 800, "Question Set") x = 60 y = 760 n = 1 for each_quest_ans in quest_ans_set: p.drawString(x, y, str('Q.%s ' % n) + str(each_quest_ans[0])) n += 1 y -= 20 p.drawString(x, y, 'Ans: ' + str(each_quest_ans[1])) y -= 30 p.showPage() p.save() file_data.seek(0) return Response(file_data.read(), mimetype="application/pdf", headers={ "Content-disposition": "attachment; filename=Question Report.pdf" }) else: flash( 'Please log-in with Administrator account to view the control panel' ) return redirect(url_for('index'))
class ZipArchiver(zipfile.ZipFile, AbstractArchiver): def __init__(self): self.buffer = StringIO() self.position = 0 zipfile.ZipFile.__init__(self, self.buffer, mode='w', allowZip64=True) def beginFile(self, file): AbstractArchiver.beginFile(self, file) if file.get('path') is None: ftime = time.localtime() else: ftime = time.localtime(os.path.getctime(file.get('path'))) self.zipInfo = zipfile.ZipInfo(self.destinationPath(file), ftime[:6]) self.reader.seek(0, 2) self.zipInfo.file_size = self.zipInfo.compress_size = self.reader.tell( ) self.reader.seek(0) self.zipInfo.flag_bits = 0x00 self.zipInfo.header_offset = self.position self.zipInfo.CRC = self.CRC32() self._writecheck(self.zipInfo) self._didModify = True self.fp.write(self.zipInfo.FileHeader()) self.filelist.append(self.zipInfo) self.NameToInfo[self.zipInfo.filename] = self.zipInfo return def readBlock(self, block_size): self.fp.write(self.reader.read(block_size)) block = self.buffer.getvalue() self.buffer.truncate(0) self.position += len(block) return block def readEnding(self): self.buffer.seek(self.position) self.close() newPos = self.buffer.tell() self.buffer.seek(self.position) block = self.buffer.read(newPos - self.position + 1) self.buffer.truncate(0) return block def EOF(self): if self.reader.tell() >= self.zipInfo.file_size: return True return False def CRC32(self): block = 1 CRC = 0 self.reader.seek(0) while block: block = self.reader.read(65536) CRC = zlib.crc32(block, CRC) & 0xffffffff self.reader.seek(0) return CRC def getContentType(self): return 'application/zip' def getFileExtension(self): return '.zip'
def pxsuptime(supfile, base): """extract subtitles from ProjectX-generated .sup file. Picky!""" # Here thanks go to ProjetcX source, http://www.via.ecp.fr/~sam/doc/dvd/ # and gtkspu program in gopchop distribution f = open(supfile, 'rb') if f.read(2) != b'SP': raise Exception("Syncword missing. XXX bailing out.") image = 1 # 1-based for feh(1) file number counting compatibility while True: # X.java reads 5 bytes of pts, SubPicture.java writes 4. With # 4 bytes 47721 seconds (13.25 hours) can be handled. pts, = struct.unpack('<Lxxxx', f.read(8)) size, pack = struct.unpack('>HH', f.read(4)) #print pts / 90, 'ms.', size, pack data = f.read(pack - 4) ctrl = StringIO(f.read(size - pack)) # parsing control info prev = 0 while True: date, = struct.unpack('>H', ctrl.read(2)) next, = struct.unpack('>H', ctrl.read(2)) # XXX while True: cmd = ord(ctrl.read(1)) if cmd == 0x00: # force display: continue if cmd == 0x01: # start date (read above) start = date # XXX + previous continue if cmd == 0x02: # stop date (read above) end = date # XXX + previous continue if cmd == 0x03: # palette xpalette = ctrl.read(2) continue if cmd == 0x04: # alpha channel alpha = ctrl.read(2) continue if cmd == 0x05: # coordinates coords = ctrl.read(6) x1 = (xord(coords[0]) << 4) + (xord(coords[1]) >> 4) x2 = ((xord(coords[1]) & 0xf) << 8) + xord(coords[2]) y1 = (xord(coords[3]) << 4) + (xord(coords[4]) >> 4) y2 = ((xord(coords[4]) & 0xf) << 8) + xord(coords[5]) continue if cmd == 0x06: # rle offsets top_field, bottom_field = struct.unpack( '>HH', ctrl.read(4)) continue if cmd == 0xff: # end command break else: raise Execption("%d: Unknown control sequence" % cmd) if prev == next: break prev = next startpts = pts endpts = pts + end * 900 # (matches .son) other values seen: 1000, 1024 sptstr = pts2ts(pts) width = x2 - x1 + 1 if width % 2 != 0: print("Image %d width (%d) is not divisible by 2." % (image, width), file=sys.stderr, end=' ') print("Check %s-%05d.bmp" % (base, image), file=sys.stderr) print("image='%d' start='%s' end='%s' x='%d' y='%d' w='%d' h='%d'" % (image, sptstr, pts2ts(endpts), x1, y1, width, y2 - y1 + 1)) image = image + 1 if f.read(2) != b'SP': if len(f.read(1)) == 0: return # EOF raise Exception("Syncword missing. XXX bailing out.")
class TestFileTransferPerformance(unittest.TestCase): def setUp(self): self.test_file_contents = open(get_book_path('pg1661.epub'), "rb").read() self.file_stream = StringIO(self.test_file_contents) self.received_file_contents = "" # noinspection PyUnusedLocal def file_received(file_hash, extension, content, more_parts_follow): self.received_file_contents += content self.client_control = mock.MagicMock() self.client_control.command_deliver_file_received.side_effect = file_received self.server_control = mock.MagicMock() def _setup_loopback_transport(self, client_secure_channel, server_secure_channel): self.client_transport = pydb.com.transport.localloopbacktransportprotocol.LocalLoopBackTransportProtocol( client_secure_channel) self.server_transport = pydb.com.transport.localloopbacktransportprotocol.LocalLoopBackTransportProtocol( server_secure_channel) client_secure_channel.set_lower_layer(self.client_transport) server_secure_channel.set_lower_layer(self.server_transport) self.client_transport.set_partner(self.server_transport) self.server_transport.set_partner(self.client_transport) def _run_benchmark(self, secure_channel_name, client_secure_channel, server_session): client_secure_channel.initiate_secure_channel() start_wire_byte_count = self.server_transport.bytes_sent() start_time = time.clock() for i in xrange(FILE_DELIVERY_REPETITIONS): self.received_file_contents = "" server_session.deliver_file('a_hash', 'epub', self.file_stream.read(), more_parts_follow=False) self.file_stream.seek(0) stop_time = time.clock() self.assertEqual(self.received_file_contents, self.test_file_contents) duration = stop_time - start_time if duration == 0: duration = 0.001 payload_bandwidth_kbps = len(self.test_file_contents) * FILE_DELIVERY_REPETITIONS / duration / 1024 stop_wire_byte_count = self.server_transport.bytes_sent() bytes_sent_by_server = (stop_wire_byte_count-start_wire_byte_count) / FILE_DELIVERY_REPETITIONS overhead_bytes = bytes_sent_by_server-len(self.test_file_contents) print("Loopback results {:>60}: {:8} kbps, {:7.1f} ms, encoding overhead: {:7} bytes" .format(secure_channel_name, int(payload_bandwidth_kbps), round(duration * 1000, 1), overhead_bytes)) def test_01_json_session_with_aeshmac_secure_channel(self): client_session = pydb.com.jsonsession.JsonSession(self.client_control) server_session = pydb.com.jsonsession.JsonSession(self.server_control) client_secure_channel = pydb.com.securechannel.aeshmacsecurechannel.AesHmacSecureChannel( client_session, pre_shared_secret_passphrase="hello") server_secure_channel = pydb.com.securechannel.aeshmacsecurechannel.AesHmacSecureChannel( server_session, friends=[ {'name': 'test friend', 'id': 1, 'comm_data': {'secret': 'hello'}} ]) client_session.set_lower_layer(client_secure_channel) server_session.set_lower_layer(server_secure_channel) self._setup_loopback_transport(client_secure_channel, server_secure_channel) self._run_benchmark('JsonSession with AesHmacSecureChannel', client_secure_channel, server_session) def test_02_json_session_with_insecure_channel(self): client_session = pydb.com.jsonsession.JsonSession(self.client_control) server_session = pydb.com.jsonsession.JsonSession(self.server_control) client_secure_channel = pydb.com.securechannel.insecurechannel.InsecureChannel( client_session) server_secure_channel = pydb.com.securechannel.insecurechannel.InsecureChannel( server_session) client_session.set_lower_layer(client_secure_channel) server_session.set_lower_layer(server_secure_channel) self._setup_loopback_transport(client_secure_channel, server_secure_channel) self._run_benchmark('JsonSession with InsecureChannel', client_secure_channel, server_session) def test_03_json_and_binary_session_with_aeshmac_secure_channel(self): client_session = pydb.com.json_and_binary_session.JsonAndBinarySession(self.client_control) server_session = pydb.com.json_and_binary_session.JsonAndBinarySession(self.server_control) client_secure_channel = pydb.com.securechannel.aeshmacsecurechannel.AesHmacSecureChannel( client_session, pre_shared_secret_passphrase="hello") server_secure_channel = pydb.com.securechannel.aeshmacsecurechannel.AesHmacSecureChannel( server_session, friends=[ {'name': 'test friend', 'id': 1, 'comm_data': {'secret': 'hello'}} ]) client_session.set_lower_layer(client_secure_channel) server_session.set_lower_layer(server_secure_channel) self._setup_loopback_transport(client_secure_channel, server_secure_channel) self._run_benchmark('JsonAndBinarySession with AesHmacSecureChannel', client_secure_channel, server_session) def test_04_json_and_binary_session_with_insecure_channel(self): client_session = pydb.com.json_and_binary_session.JsonAndBinarySession(self.client_control) server_session = pydb.com.json_and_binary_session.JsonAndBinarySession(self.server_control) client_secure_channel = pydb.com.securechannel.insecurechannel.InsecureChannel( client_session) server_secure_channel = pydb.com.securechannel.insecurechannel.InsecureChannel( server_session) client_session.set_lower_layer(client_secure_channel) server_session.set_lower_layer(server_secure_channel) self._setup_loopback_transport(client_secure_channel, server_secure_channel) self._run_benchmark('JsonAndBinarySession with InsecureChannel', client_secure_channel, server_session) def test_05_json_session_with_aeshmac_secure_channel_compression_level_0(self): client_session = pydb.com.jsonsession.JsonSession(self.client_control) server_session = pydb.com.jsonsession.JsonSession(self.server_control) client_secure_channel = pydb.com.securechannel.aeshmacsecurechannel.AesHmacSecureChannel( client_session, pre_shared_secret_passphrase="hello") client_secure_channel.set_compression_level(0) server_secure_channel = pydb.com.securechannel.aeshmacsecurechannel.AesHmacSecureChannel( server_session, friends=[ {'name': 'test friend', 'id': 1, 'comm_data': {'secret': 'hello'}} ]) server_secure_channel.set_compression_level(0) client_session.set_lower_layer(client_secure_channel) server_session.set_lower_layer(server_secure_channel) self._setup_loopback_transport(client_secure_channel, server_secure_channel) self._run_benchmark('JsonSession with AesHmacSecureChannel compress 0', client_secure_channel, server_session) def test_06_json_and_binary_session_with_aeshmac_secure_channel_compression_level_0(self): client_session = pydb.com.json_and_binary_session.JsonAndBinarySession(self.client_control) server_session = pydb.com.json_and_binary_session.JsonAndBinarySession(self.server_control) client_secure_channel = pydb.com.securechannel.aeshmacsecurechannel.AesHmacSecureChannel( client_session, pre_shared_secret_passphrase="hello") client_secure_channel.set_compression_level(0) server_secure_channel = pydb.com.securechannel.aeshmacsecurechannel.AesHmacSecureChannel( server_session, friends=[ {'name': 'test friend', 'id': 1, 'comm_data': {'secret': 'hello'}} ]) server_secure_channel.set_compression_level(0) client_session.set_lower_layer(client_secure_channel) server_session.set_lower_layer(server_secure_channel) self._setup_loopback_transport(client_secure_channel, server_secure_channel) self._run_benchmark('JsonAndBinarySession with AesHmacSecureChannel compress 0', client_secure_channel, server_session) def test_07_json_session_with_aeshmac_secure_channel_without_compression(self): client_session = pydb.com.jsonsession.JsonSession(self.client_control) server_session = pydb.com.jsonsession.JsonSession(self.server_control) client_secure_channel = pydb.com.securechannel.aeshmacsecurechannel.AesHmacSecureChannel( client_session, pre_shared_secret_passphrase="hello") client_secure_channel.set_compression_level(None) server_secure_channel = pydb.com.securechannel.aeshmacsecurechannel.AesHmacSecureChannel( server_session, friends=[ {'name': 'test friend', 'id': 1, 'comm_data': {'secret': 'hello'}} ]) server_secure_channel.set_compression_level(None) client_session.set_lower_layer(client_secure_channel) server_session.set_lower_layer(server_secure_channel) self._setup_loopback_transport(client_secure_channel, server_secure_channel) self._run_benchmark('JsonSession with AesHmacSecureChannel compress off', client_secure_channel, server_session) def test_08_json_and_binary_session_with_aeshmac_secure_channel_without_compression(self): client_session = pydb.com.json_and_binary_session.JsonAndBinarySession(self.client_control) server_session = pydb.com.json_and_binary_session.JsonAndBinarySession(self.server_control) client_secure_channel = pydb.com.securechannel.aeshmacsecurechannel.AesHmacSecureChannel( client_session, pre_shared_secret_passphrase="hello") client_secure_channel.set_compression_level(None) server_secure_channel = pydb.com.securechannel.aeshmacsecurechannel.AesHmacSecureChannel( server_session, friends=[ {'name': 'test friend', 'id': 1, 'comm_data': {'secret': 'hello'}} ]) server_secure_channel.set_compression_level(None) client_session.set_lower_layer(client_secure_channel) server_session.set_lower_layer(server_secure_channel) self._setup_loopback_transport(client_secure_channel, server_secure_channel) self._run_benchmark('JsonAndBinarySession with AesHmacSecureChannel compress off', client_secure_channel, server_session)
def _proxy(self, url, params=None, method=None, body=None, headers=None): # get query string params = dict(self.request.params) if params is None else params parsed_url = urlparse(url) all_params = parse_qs(parsed_url.query) for p in all_params: all_params[p] = ",".join(all_params[p]) all_params.update(params) params_encoded = {} for k, v in all_params.iteritems(): params_encoded[k] = unicode(v).encode("utf-8") query_string = urllib.urlencode(params_encoded) if parsed_url.port is None: url = "%s://%s%s?%s" % (parsed_url.scheme, parsed_url.hostname, parsed_url.path, query_string) else: # pragma: nocover url = "%s://%s:%i%s?%s" % (parsed_url.scheme, parsed_url.hostname, parsed_url.port, parsed_url.path, query_string) log.info("Send query to URL:\n%s." % url) if method is None: method = self.request.method # forward request to target (without Host Header) http = httplib2.Http() if headers is None: # pragma: nocover headers = dict(self.request.headers) if parsed_url.hostname != "localhost": headers.pop("Host") headers["Cache-Control"] = "no-cache" if method in ["POST", "PUT"] and body is None: # pragma: nocover body = StringIO(self.request.body) try: if method in ["POST", "PUT"]: resp, content = http.request(url, method=method, body=body, headers=headers) else: resp, content = http.request(url, method=method, headers=headers) except Exception as e: # pragma: nocover log.error("Error '%s' while getting the URL:\n%s\nMethode: %s." % (sys.exc_info()[0], url, method)) log.error("--- With headers ---\n%s" % "\n".join(["%s: %s" % h for h in headers.items()])) log.error("--- Exception ---") log.exception(e) if method in ["POST", "PUT"]: log.error("--- With body ---") if hasattr(body, "read"): body.reset() log.error(body.read()) else: log.error(body) raise HTTPBadGateway("See logs for detail") if resp.status < 200 or resp.status >= 300: # pragma: no cover log.error("Error '%s' in response of URL:\n%s." % (resp.reason, url)) log.error("Status: %i" % resp.status) log.error("Method: %s" % method) log.error("--- With headers ---\n%s" % "\n".join(["%s: %s" % h for h in headers.items()])) if method == "POST": log.error("--- Query with body ---") if hasattr(body, "read"): body.reset() log.error(body.read()) else: log.error(body) log.error("--- Return content ---") log.error(content) raise HTTPInternalServerError("See logs for details") return resp, content
def captcha_image(request, key): store = get_object_or_404(CaptchaStore, hashkey=key) text = store.challenge if settings.CAPTCHA_FONT_PATH.lower().strip().endswith('ttf'): font = ImageFont.truetype(settings.CAPTCHA_FONT_PATH, settings.CAPTCHA_FONT_SIZE) else: font = ImageFont.load(settings.CAPTCHA_FONT_PATH) size = font.getsize(text) size = (size[0] * 2, size[1]) image = Image.new('RGB', size, settings.CAPTCHA_BACKGROUND_COLOR) try: PIL_VERSION = int(NON_DIGITS_RX.sub('', Image.VERSION)) except: PIL_VERSION = 116 xpos = 2 for char in text: fgimage = Image.new('RGB', size, settings.CAPTCHA_FOREGROUND_COLOR) charimage = Image.new('L', font.getsize(' %s ' % char), '#000000') chardraw = ImageDraw.Draw(charimage) chardraw.text((0, 0), ' %s ' % char, font=font, fill='#ffffff') if settings.CAPTCHA_LETTER_ROTATION: if PIL_VERSION >= 116: charimage = charimage.rotate( random.randrange(*settings.CAPTCHA_LETTER_ROTATION), expand=0, resample=Image.BICUBIC) else: charimage = charimage.rotate( random.randrange(*settings.CAPTCHA_LETTER_ROTATION), resample=Image.BICUBIC) charimage = charimage.crop(charimage.getbbox()) maskimage = Image.new('L', size) maskimage.paste( charimage, (xpos, 4, xpos + charimage.size[0], 4 + charimage.size[1])) size = maskimage.size image = Image.composite(fgimage, image, maskimage) xpos = xpos + 2 + charimage.size[0] image = image.crop((0, 0, xpos + 1, size[1])) draw = ImageDraw.Draw(image) for f in settings.noise_functions(): draw = f(draw, image) for f in settings.filter_functions(): image = f(image) out = StringIO() image.save(out, "PNG") out.seek(0) response = HttpResponse() response['Content-Type'] = 'image/png' response.write(out.read()) return response
def export_all_responses(): s3mgr.load("survey_series") s3mgr.load("survey_section") s3mgr.load("survey_complete") s3 = response.s3 try: import xlwt except ImportError: output = s3_rest_controller("survey", "series", rheader=s3.survey_series_rheader) return output series_id = request.args[0] seriesName = response.s3.survey_getSeriesName(series_id) sectionBreak = False filename = "%s_All_responses.xls" % seriesName contentType = ".xls" output = StringIO() book = xlwt.Workbook(encoding="utf-8") # get all questions and write out as a heading col = 0 completeRow = {} nextRow = 2 qstnList = response.s3.survey_getAllQuestionsForSeries(series_id) if len(qstnList) > 256: sectionList = s3.survey_getAllSectionsForSeries(series_id) sectionBreak = True if sectionBreak: sheets = {} cols = {} for section in sectionList: sheetName = section["name"].split(" ")[0] if sheetName not in sheets: sheets[sheetName] = book.add_sheet(sheetName) cols[sheetName] = 0 else: sheet = book.add_sheet(T("Responses")) for qstn in qstnList: if sectionBreak: sheetName = qstn["section"].split(" ")[0] sheet = sheets[sheetName] col = cols[sheetName] row = 0 sheet.write(row,col,qstn["code"]) row += 1 widgetObj = s3.survey_getWidgetFromQuestion(qstn["qstn_id"]) sheet.write(row,col,widgetObj.fullName()) # for each question get the response allResponses = s3.survey_getAllAnswersForQuestionInSeries(qstn["qstn_id"], series_id) for answer in allResponses: value = answer["value"] complete_id = answer["complete_id"] if complete_id in completeRow: row = completeRow[complete_id] else: completeRow[complete_id] = nextRow row = nextRow nextRow += 1 sheet.write(row,col,value) col += 1 if sectionBreak: cols[sheetName] += 1 sheet.panes_frozen = True sheet.horz_split_pos = 2 book.save(output) output.seek(0) response.headers["Content-Type"] = contenttype(contentType) response.headers["Content-disposition"] = "attachment; filename=\"%s\"" % filename return output.read()