def generate_chunk(self, data): bufsize = 1024 io = StringIO(data) while True: buf = io.read(bufsize) if not buf: return yield buf io.close()
def write_xls(file_name, sheet_name, headings, data, heading_xf, data_xfs, kinds): book = xlwt.Workbook(encoding='utf8') sheet = book.add_sheet(sheet_name) rowx = 0 for colx, value in enumerate(headings): sheet.write(rowx, colx, value, heading_xf) sheet.set_panes_frozen(True) # frozen headings instead of split panes sheet.set_horz_split_pos(rowx+1) # in general, freeze after last heading row sheet.set_remove_splits(True) # if user does unfreeze, don't leave a split there sheet.set_col_default_width(True) color_charts = {} for state, color in state_color_map.iteritems() : color_charts[state] = xlwt.easyxf("""font: height 180, name Times New Roman, colour_index %s, bold on; align: wrap on, vert centre, horiz center """ % color) for row in data: rowx += 1 for colx, value in enumerate(row) : style = data_xfs[colx] if file_name == "requisitions" and kinds[colx] != 'money' : state = row[-1] style = color_charts[state] sheet.write(rowx, colx, (value not in ('None', '0.00') and value) or '', style) # book.save(file_name) # ene hesgiig huulav from StringIO import StringIO result = StringIO() book.save(result) result.seek(0) response = HttpResponse(result.read(), mimetype='application/ms-excel') if file_name: response['Content-Disposition'] = 'attachment; filename='+file_name+".xls" else: response['Content-Disposition'] = 'attachment; filename=export.xls' return response
class SOAPRequestHandler(BaseSOAPRequestHandler): '''SOAP handler. ''' def _read_chunk_size(self): current_size = "" while '\n' not in current_size: current_size += self.rfile.read(1) current_size = int(current_size, 16) return current_size def _fix_chunked_encoding(self): from StringIO import StringIO if self.headers.get('transfer-encoding', '') != 'chunked': return full_data = "" while True: current_size = self._read_chunk_size() if current_size == 0: break full_data += self.rfile.read(current_size) self.rfile.read(2) # CRLF after chunk self.rfile = StringIO(full_data) self.headers['content-length'] = str(len(full_data)) return full_data def do_POST(self): '''The POST command. action -- SOAPAction(HTTP header) or wsa:Action(SOAP:Header) ''' self._fix_chunked_encoding() logger.debug("Request Host: {}".format(self.client_address)) logger.debug("Request URI: {}".format(self.requestline)) for key, value in self.headers.items(): logger.debug("Request Header: {}: {}".format(key, value)) content_type = self.headers.get("content-type", '') action_matchobj = re.search("action=\"(urn:\w+)\"", content_type) if action_matchobj is not None: # SOAP 1.2 soapAction = action_matchobj.group(1) else: # SOAP 1.1 soapAction = self.headers.getheader('SOAPAction') if soapAction: soapAction = soapAction.strip('\'"') self._soapAction = soapAction post = self.path if not post: raise PostNotSpecified, 'HTTP POST not specified in request' post = post.strip('\'"') try: ct = self.headers['content-type'] if ct.startswith('multipart/'): cid = resolvers.MIMEResolver(ct, self.rfile) xml = cid.GetSOAPPart() ps = ParsedSoap(xml, resolver=cid.Resolve) else: length = int(self.headers['content-length']) xml = self.rfile.read(length) logger.debug("Request Body: {}".format(xml)) ps = ParsedSoap(xml) except ParseException, e: self.send_fault(FaultFromZSIException(e)) except Exception, e: # Faulted while processing; assume it's in the header. self.send_fault(FaultFromException(e, 1, sys.exc_info()[2]))
def __init__(self, handle): '''Initialize this C3D file by reading header and parameter data. Arguments --------- handle : file handle Read metadata and C3D motion frames from the given file handle. This handle is assumed to be `seek`-able and `read`-able. The handle must remain open for the life of the `Reader` instance. The `Reader` does not `close` the handle. Raises ------ ValueError, if the processor metadata in the C3D file is anything other than 84 (Intel format) or 85 (DEC format). ''' super(Reader, self).__init__(Header(handle)) self._handle = handle self._handle.seek((self.header.parameter_block - 1) * 512) # metadata header buf = self._handle.read(4) _, _, parameter_blocks, processor = struct.unpack('BBBB', buf) if processor != PROCESSOR_INTEL: raise ValueError( 'we only read Intel C3D files (got processor {})'.format( processor)) # read all parameter blocks as a single chunk to avoid block # boundary issues. bytes = self._handle.read(512 * parameter_blocks - 4) while bytes: buf = FileIO(bytes) chars_in_name, group_id = struct.unpack('bb', buf.read(2)) if group_id == 0 or chars_in_name == 0: # we've reached the end of the parameter section. break name = buf.read(abs(chars_in_name)).upper() offset_to_next, = struct.unpack('<h', buf.read(2)) if group_id > 0: # we've just started reading a parameter. if its group doesn't # exist, create a blank one. add the parameter to the group. self.setdefault(group_id, Group()).add_param(name, handle=buf) else: # we've just started reading a group. if a group with the # appropriate id exists already (because we've already created # it for a parameter), just set the name of the group. # otherwise, add a new group. group_id = abs(group_id) size, = struct.unpack('B', buf.read(1)) desc = size and buf.read(size) or '' group = self.get(group_id) if group is not None: group.name = name group.desc = desc self[name] = group else: self.add_group(group_id, name, desc) bytes = bytes[2 + abs(chars_in_name) + offset_to_next:] self.check_metadata()