def test_ByteSequence(self): b1 = uno.ByteSequence(bytes("abcdefg", encoding="utf8")) b2 = uno.ByteSequence(bytes("abcdefg", encoding="utf8")) b3 = uno.ByteSequence(bytes("1234567", encoding="utf8")) self.assertEqual(b1, b1) self.assertEqual(b1, b2) self.assertFalse(b1 != b2) self.assertNotEqual(b1, b3)
def read(size=None): if size is None: data = '' while True: bytes = uno.ByteSequence('') n_read, bytes = stream.readBytes(bytes, 4096) if n_read == 0: return data data += bytes.value bytes = uno.ByteSequence('') n_read, bytes = stream.readBytes(bytes, size) return bytes.value
def doConvert(self, buff): inputprops = self.unoProps(Hidden=True, ReadOnly=True, UpdateDocMode=QUIET_UPDATE) inputStream = self.svcmgr.createInstanceWithContext( "com.sun.star.io.SequenceInputStream", self.context) inputStream.initialize( (uno.ByteSequence(buff), )) #Use stream from node ? inputprops += self.unoProps(InputStream=inputStream) inputurl = 'private:stream' document = self.desktop.loadComponentFromURL(inputurl, "_blank", 0, inputprops) if not document: raise Exception("The document could not be opened.") outputStream = OutputStream() outputprops = self.unoProps(FilterName=self.filterName, OutputStream=outputStream, Overwrite=True) outputurl = "private:stream" try: document.storeToURL(outputurl, tuple(outputprops)) except IOException as e: raise Exception( "Unable to store document to %s (ErrCode %d)\n\nProperties: %s" % (outputurl, e.ErrCode, outputprops), None) document.dispose() document.close(True) return outputStream.buff
def insertSubreports(self, oo_subreports): """ Inserts the given file into the current document. The file contents will replace the placeholder text. """ import os for subreport in oo_subreports: fd = file(subreport, 'rb') placeholder_text = "<insert_doc('%s')>" % subreport subdata = fd.read() subStream = self.serviceManager.createInstanceWithContext( "com.sun.star.io.SequenceInputStream", self.localContext) subStream.initialize((uno.ByteSequence(subdata), )) search = self.document.createSearchDescriptor() search.SearchString = placeholder_text found = self.document.findFirst(search) #while found: try: found.insertDocumentFromURL( 'private:stream', self._toProperties(InputStream=subStream, FilterName="writer8")) except Exception, ex: print( _("Error inserting file %s on the OpenOffice document: %s") % (subreport, ex)) #found = self.document.findNext(found, search) os.unlink(subreport)
def actionPerformed(self, event): try: if event.ActionCommand == "Run": code = self.editor.getControl("EditorTextField").getText() code = ensureSourceState(code) mod = imp.new_module("ooo_script_framework") mod.__dict__[ GLOBAL_SCRIPTCONTEXT_NAME] = self.provCtx.scriptContext exec(code, mod.__dict__) values = mod.__dict__.get(CALLABLE_CONTAINER_NAME, None) if not values: values = mod.__dict__.values() for i in values: if isScript(i): i() break elif event.ActionCommand == "Save": toWrite = uno.ByteSequence( self.editor.getControl("EditorTextField").getText().encode( sys.getdefaultencoding())) copyUrl = self.uri + ".orig" self.provCtx.sfa.move(self.uri, copyUrl) out = self.provCtx.sfa.openFileWrite(self.uri) out.writeBytes(toWrite) out.close() self.provCtx.sfa.kill(copyUrl) # log.debug("Save is not implemented yet") # text = self.editor.getControl("EditorTextField").getText() # log.debug("Would save: " + text) except: # TODO: add an error box here! log.error(lastException2String())
def convertByStream(self, stdinBytes, outputExt='pdf'): inputStream = self.ServiceManager.createInstanceWithContext( "com.sun.star.io.SequenceInputStream", self.localContext) inputStream.initialize((uno.ByteSequence(stdinBytes), )) document = self.desktop.loadComponentFromURL( 'private:stream', "_blank", 0, self._toProperties(Hidden=True, InputStream=inputStream)) if not document: raise Exception, "Error making document" try: document.refresh() except AttributeError: pass filterName = FILTER_MAP[outputExt] outputStream = OutputStream(False) try: outputprops = self._toProperties(OutputStream=outputStream, FilterName=filterName, Overwrite=True) document.storeToURL("private:stream", outputprops) finally: document.close(True) data = outputStream.data.getvalue() outputStream.close() return data
def run(self): address = self.controller.Configuration.Url.Scope.Provider.RedirectAddress port = self.controller.Configuration.Url.Scope.Provider.RedirectPort result = uno.getConstantByName( 'com.sun.star.ui.dialogs.ExecutableDialogResults.CANCEL') connection = self.acceptor.accept( 'socket,host=%s,port=%s,tcpNoDelay=1' % (address, port)) if connection: with self.lock: result = self._getResult(connection) basename = getResourceLocation(self.ctx, g_identifier, 'OAuth2OOo') basename += '/OAuth2Success_%s.html' if result else '/OAuth2Error_%s.html' locale = getCurrentLocale(self.ctx) length, body = getFileSequence(self.ctx, basename % locale.Language, basename % 'en') header = uno.ByteSequence(b'''\ HTTP/1.1 200 OK Content-Length: %d Content-Type: text/html; charset=utf-8 Connection: Closed ''' % length) connection.write(header + body) connection.close() self.acceptor.stopAccepting() self.controller.Handler.Wizard.DialogWindow.endDialog(result) self.lock.notifyAll()
def convertByStream(self, stdinBytes, filterName): inputStream = self.serviceManager.createInstanceWithContext("com.sun.star.io.SequenceInputStream", self.localContext) inputStream.initialize((uno.ByteSequence(stdinBytes),)) document = self.desktop.loadComponentFromURL('private:stream', "_blank", 0, self._toProperties( InputStream=inputStream, Hidden=False)) if not document: raise Exception, "Error making document" try: document.refresh() except AttributeError: pass outputStream = OutputStreamWrapper(False) properties = dict( Overwrite=True, OutputStream=outputStream, FilterName=filterName) anyException = False if "pdf_" in filterName: properties["FilterData"] = self._addPdf() try: document.storeToURL('private:stream', self._toProperties(**properties)) except Exception, e: anyException = e pass
def storeByPath(self, stdinBytes, outputExt='pdf'): inputStream = self.ServiceManager.createInstanceWithContext( "com.sun.star.io.SequenceInputStream", self.localContext) inputStream.initialize((uno.ByteSequence(stdinBytes), )) document = self.desktop.loadComponentFromURL( 'private:stream', "_blank", 0, self._toProperties(Hidden=True, InputStream=inputStream)) if not document: raise Exception, "Error making document" try: document.refresh() except AttributeError: pass filterName = FILTER_MAP[outputExt] outputFile = tempfile.mktemp(suffix='.%s' % outputExt) outputUrl = self._toFileUrl(outputFile) try: document.storeToURL( outputUrl, self._toProperties(FilterName=FILTER_MAP[outputExt], Overwrite=True)) finally: document.close(True) data = open(outputFile, "rb").read() return data
def putDocument(self, data): try: self.desktop = self._context.ServiceManager.createInstanceWithContext( "com.sun.star.frame.Desktop", self._context) except UnknownPropertyException: self._context = self._resolver.resolve(RESOLVESTR % (self._host, self._port)) self.desktop = self._context.ServiceManager.createInstanceWithContext( "com.sun.star.frame.Desktop", self._context) inputStream = self.serviceManager.createInstanceWithContext( "com.sun.star.io.SequenceInputStream", self.localContext) inputStream.initialize((uno.ByteSequence(data), )) props = self._toProperties(InputStream=inputStream, FilterName="writer8") try: self.document = self.desktop.loadComponentFromURL( 'private:stream', "_blank", 0, props) except: exceptionType, exceptionValue, exceptionTraceback = sys.exc_info() traceback.print_exception(exceptionType, exceptionValue, exceptionTraceback, limit=2, file=sys.stdout) inputStream.closeInput()
def convert_by_stream(self, data, format=LIBREOFFICE_OPEN_DOCUMENT): data.seek(0) input_stream = self._service_manager.createInstanceWithContext( "com.sun.star.io.SequenceInputStream", self._local_context) input_stream.initialize((uno.ByteSequence(data.read()), )) document = self._desktop.loadComponentFromURL( 'private:stream', "_blank", 0, self._to_properties(InputStream=input_stream, ReadOnly=True)) if not document: raise Exception, "Error making document" try: document.refresh() except AttributeError: pass output_stream = output_stream_wrapper() try: document.storeToURL( 'private:stream', self._to_properties(OutputStream=output_stream, FilterName=format)) finally: document.close(True) if format == LIBREOFFICE_OPEN_DOCUMENT: doc_type = document_type.detect_document_type(output_stream.data) if doc_type != document_type.types.oasis_open_document: raise docvert_exception.converter_unable_to_generate_open_document( ) return output_stream.data
def run(self): connection = None try: connection = self.acceptor.accept(self.argument) except AlreadyAcceptingException as e: msg = "Error: %s - %s" % (e, traceback.print_exc()) logMessage(self.ctx, SEVERE, msg, 'Server', 'run()') except ConnectionSetupException as e: msg = "Error: %s - %s" % (e, traceback.print_exc()) logMessage(self.ctx, SEVERE, msg, 'Server', 'run()') except IllegalArgumentException as e: msg = "Error: %s - %s" % (e, traceback.print_exc()) logMessage(self.ctx, SEVERE, msg, 'Server', 'run()') if connection: with self.lock: result = self._getResult(connection) location = self._getResultLocation(result) location += '?%s' % urlencode({'user': self.user}) header = '''\ HTTP/1.1 302 Found Location: %s Connection: Closed ''' % location try: connection.write(uno.ByteSequence(header.encode('utf8'))) except IOException as e: msg = "Error: %s - %s" % (e, traceback.print_exc()) logMessage(self.ctx, SEVERE, msg, 'Server', 'run()') connection.flush() connection.close() self.acceptor.stopAccepting() self.lock.notifyAll() logMessage(self.ctx, INFO, "Server Running ... Done", 'Server', 'run()')
def getFileSequence(ctx, url, default=None): length, sequence = 0, uno.ByteSequence(b'') fs = getSimpleFile(ctx) if fs.exists(url): length, sequence = _getSequence(fs.openFileRead(url), fs.getSize(url)) elif default is not None and fs.exists(default): length, sequence = _getSequence(fs.openFileRead(default), fs.getSize(default)) return length, sequence
def joinDocuments(self, docs): while(docs): subStream = self.serviceManager.createInstanceWithContext("com.sun.star.io.SequenceInputStream", self.localContext) subStream.initialize((uno.ByteSequence(docs.pop()),)) try: self.document.Text.getEnd().insertDocumentFromURL('private:stream', self._toProperties(InputStream = subStream, FilterName = "writer8")) except Exception, ex: print (_("Error inserting file %s on the OpenOffice document: %s") % (docs, ex))
def readBytes( self, retSeq, nByteCount ): nRet = 0 if( self.nIndex + nByteCount > len(self.s) ): nRet = len(self.s) - self.nIndex else: nRet = nByteCount retSeq = uno.ByteSequence(self.s.value[self.nIndex : self.nIndex + nRet ]) self.nIndex = self.nIndex + nRet return nRet, retSeq
def readTextFromStream(inputStream): # read the file code = uno.ByteSequence("") while True: read, out = inputStream.readBytes(None, BLOCK_SIZE) code = code + out if read < BLOCK_SIZE: break return code.value
def convert(self, document, format=None, output_filename=None, delete_on_close=True): output_filename, format = guess_format_and_filename( output_filename, format) ### Do the OpenOffice component dance context = uno.getComponentContext() resolver = context.ServiceManager.createInstanceWithContext( 'com.sun.star.bridge.UnoUrlResolver', context) unocontext = resolver.resolve('uno:%s' % OOO_CONNECTION) ### And some more OpenOffice magic unosvcmgr = unocontext.ServiceManager desktop = unosvcmgr.createInstanceWithContext( 'com.sun.star.frame.Desktop', unocontext) config = unosvcmgr.createInstanceWithContext( 'com.sun.star.configuration.ConfigurationProvider', unocontext) ### Load inputfile instream = InputStream(uno.ByteSequence(document.read())) inputprops = [ PropertyValue('InputStream', 0, instream, 0), ] if document.format == 'html': inputprops.append( PropertyValue('FilterName', 0, 'HTML (StarWriter)', 0)) doc = desktop.loadComponentFromURL('private:stream', '_blank', 0, tuple(inputprops)) ### Update document links # skip ... ### Update document indexes # skip ... ### Write outputfile fd = open(output_filename, 'w') filter_name = formats[format] outputprops = [ PropertyValue( 'FilterData', 0, uno.Any( '[]com.sun.star.beans.PropertyValue', tuple(), ), 0), PropertyValue('FilterName', 0, filter_name, 0), PropertyValue('OutputStream', 0, OutputStream(fd), 0), PropertyValue('Overwrite', 0, True, 0), ] if filter_name == 'Text (encoded)': outputprops.append(PropertyValue('FilterFlags', 0, 'UTF8, LF', 0)) doc.storeToURL('private:stream', tuple(outputprops)) doc.dispose() doc.close(True) fd.close() fd = Document(output_filename, mode='r', delete_on_close=delete_on_close) return fd
def putDocument(self, data): try: desktop = self._context.ServiceManager.createInstanceWithContext("com.sun.star.frame.Desktop", self._context) except UnknownPropertyException: self._context = self._resolver.resolve("uno:socket,host=%s,port=%s;urp;StarOffice.ComponentContext" % (self._host, self._port)) desktop = self._context.ServiceManager.createInstanceWithContext("com.sun.star.frame.Desktop", self._context) inputStream = self.serviceManager.createInstanceWithContext("com.sun.star.io.SequenceInputStream", self.localContext) inputStream.initialize((uno.ByteSequence(data),)) self.document = desktop.loadComponentFromURL('private:stream', "_blank", 0, self._toProperties(InputStream = inputStream)) inputStream.closeInput()
def __detect(self, xInputStream): bytes = uno.ByteSequence('') # Input with and without UTF-8 BOM is OK. for i in ["0 HEAD", "\ufeff0 HEAD"]: xInputStream.seek(0) # readBytes() returns a (read, bytes) tuple. bytes = xInputStream.readBytes(bytes, len(i.encode('utf-8')))[1] if bytes.value.decode('utf-8') == i: return True return False
def __detect(input_stream: Any) -> bool: byte_sequence = uno.ByteSequence(bytes()) # Input with and without UTF-8 BOM is OK. for i in ["0 HEAD", "\ufeff0 HEAD"]: input_stream.seek(0) # readBytes() returns a (read, byte_sequence) tuple. byte_sequence = input_stream.readBytes(byte_sequence, len(i.encode('utf-8')))[1] if byte_sequence.value.decode('utf-8') == i: return True return False
def create_graphic_from_binary(self, binary): """グラフィックオブジェクトを生成""" istream = self.smgr.createInstanceWithContext( CSS + ".io.SequenceInputStream", self.context) istream.initialize((uno.ByteSequence(binary), )) logging.debug("Istream created %s" % (istream)) gobj = self.graphicprovider.queryGraphic( (PropertyValue("InputStream", 0, istream, 0), )) logging.debug("queryGraphic %s" % (gobj, )) return gobj
def readBytes(self, sequence, length): i = length - len(self.buffers) if i < 0: j = abs(i) sequence = uno.ByteSequence(self.buffers[:j]) self.buffers = self.buffers[j:] return len(sequence), sequence sequence = uno.ByteSequence(self.buffers) self.buffers = b'' while i > 0: chunk = next(self.chunks, b'') j = len(chunk) if j == 0: break elif j > i: sequence += chunk[:i] self.buffers = chunk[i:] break sequence += chunk i = length - len(sequence) return len(sequence), sequence
def readTextFromStream(inputStream): # read the file code = uno.ByteSequence(b"") while True: read, out = inputStream.readBytes(None, BLOCK_SIZE) code = code + out if read < BLOCK_SIZE: break if sys.version_info[0] > 2: return str(code.value, 'utf-8') else: return code.value
def getFileSequence(ctx, url, default=None): length = 0 sequence = uno.ByteSequence(b'') fs = getSimpleFile(ctx) if fs.exists(url): inputstream = fs.openFileRead(url) size = fs.getSize(url) length, sequence = _getSequence(inputstream, size) elif default is not None and fs.exists(default): inputstream = fs.openFileRead(default) size = fs.getSize(default) length, sequence = _getSequence(inputstream, size) return length, sequence
def convert(source, target, target_format): home_dir = tempfile.mkdtemp() errcode = None popen = None try: port = get_free_port() popen, context, desktop = start_openoffice(home_dir, port) input_stream = context.ServiceManager.createInstanceWithContext( 'com.sun.star.io.SequenceInputStream', context) input_stream.initialize((uno.ByteSequence(source.read()), )) doc = desktop.loadComponentFromURL( 'private:stream', '_blank', 0, to_properties({ 'InputStream': input_stream, })) try: doc.refresh() except AttributeError: pass try: doc.storeToURL( 'private:stream', to_properties({ 'FilterName': FILTER_MAP[target_format], 'OutputStream': OutputStream(target), })) finally: doc.close(True) try: desktop.terminate() except: pass if popen.returncode is None: errcode = popen.wait() except Exception as e: print >> sys.stderr, e errcode = 1 finally: if errcode is None and popen and popen.returncode is None: try: errcode = popen.kill() except: pass time.sleep(0.5) shutil.rmtree(home_dir) exit(errcode)
def testByteSequence( self ): s = uno.ByteSequence( "ab" ) self.failUnless( s == uno.ByteSequence( "ab" ) ) self.failUnless( uno.ByteSequence( "abc" ) == s + uno.ByteSequence( "c" ) ) self.failUnless( uno.ByteSequence( "abc" ) == s + "c" ) self.failUnless( s + "c" == "abc" ) self.failUnless( s == uno.ByteSequence( s ) ) self.failUnless( s[0] == 'a' ) self.failUnless( s[1] == 'b' )
def readBytes(self, sequence, length): i = length - len(self.buffers) if i < 0: j = abs(i) sequence = uno.ByteSequence(self.buffers[:j]) self.buffers = self.buffers[j:] return len(sequence), sequence sequence = uno.ByteSequence(self.buffers) self.buffers = b'' while i > 0: chunk = next(self.chunks, b'') j = len(chunk) print("Request.InputStream.readBytes()1: %s - %s" % (j, length)) if j == 0: break elif j > i: sequence += chunk[:i] self.buffers = chunk[i:] break sequence += chunk i = length - len(sequence) print("Request.InputStream.readBytes()2: %s - %s" % (length, len(sequence))) return len(sequence), sequence
def getFileSequence(ctx, url, default=None): length = 0 sequence = uno.ByteSequence(b'') fileservice = ctx.ServiceManager.createInstance( 'com.sun.star.ucb.SimpleFileAccess') if fileservice.exists(url): inputstream = fileservice.openFileRead(url) length, sequence = inputstream.readBytes(None, fileservice.getSize(url)) inputstream.closeInput() elif default is not None and fileservice.exists(default): inputstream = fileservice.openFileRead(default) length, sequence = inputstream.readBytes(None, fileservice.getSize(default)) inputstream.closeInput() return length, sequence
def filter(self, props): try: self.props = self.toDict(props) path = unohelper.fileUrlToSystemPath(self.props["URL"]) buf = self.__toSvg(path) xInputStream = self.createUnoService("io.SequenceInputStream") xInputStream.initialize((uno.ByteSequence(buf), )) xFilter = self.createUnoService("comp.Draw.SVGFilter") xFilter.setTargetDocument(self.xDstDoc) value = PropertyValue() value.Name = "InputStream" value.Value = xInputStream xFilter.filter((value, )) return True except: self.printTraceback() return False
def _write_to_file(self, file_url, text): """ Write text to the file. """ import bookmarks.tools import uno sfa = bookmarks.tools.create_service( self.ctx, "com.sun.star.ucb.SimpleFileAccess") if sfa.exists(file_url): sfa.kill(file_url) io = sfa.openFileWrite(file_url) try: total = len(text) - 1 n = 0 while True: io.writeBytes(uno.ByteSequence(text[n:n + 0xffff])) n += 0xffff if n >= total: break except Exception as e: print(e) io.closeOutput()