def process_requirements_txt(self, repo: Addon, data: QtCore.QByteArray):
     """Process the requirements.txt metadata file"""
     self.status_message.emit(
         translate(
             "AddonsInstaller",
             "Downloaded requirements.txt for {}",
         ).format(repo.display_name)
     )
     f = io.StringIO(data.data().decode("utf8"))
     lines = f.readlines()
     for line in lines:
         break_chars = " <>=~!+#"
         package = line
         for n, c in enumerate(line):
             if c in break_chars:
                 package = line[:n].strip()
                 break
         if package:
             repo.python_requires.add(package)
     # For review and debugging purposes, store the file locally
     package_cache_directory = os.path.join(self.store, repo.name)
     if not os.path.exists(package_cache_directory):
         os.makedirs(package_cache_directory)
     new_xml_file = os.path.join(package_cache_directory, "requirements.txt")
     with open(new_xml_file, "wb") as f:
         f.write(data.data())
Example #2
0
    def testIt(self):
        w = QGLWidget()
        w.makeCurrent()

        b = QGLBuffer()
        b.setUsagePattern(QGLBuffer.DynamicDraw)

        self.assertTrue(b.create())
        self.assertTrue(b.bufferId() != 0)
        self.assertTrue(b.bind())

        data = QByteArray("12345")
        b.allocate(data)
        self.assertEqual(b.size(), data.size())

        m = b.map(QGLBuffer.ReadOnly)
        if m:
            self.assertEqual(m, py3k.buffer(py3k.b(data.data())))
            b.unmap()

            m = b.map(QGLBuffer.ReadWrite)
            m[3] = py3k.b('A')
            b.unmap()
            result, rdata = b.read(3, 1)
            self.assertTrue(result)
            self.assertEqual(py3k.b('A'), rdata.data())
        else:
            print(" memory mapping is not possible in this OpenGL implementation.")
        b.release()
Example #3
0
 def exportDipsToURL(self,
                     dipoles,
                     directoryURL,
                     fileName,
                     addDateToExport=True):
     dateStr = ("-" + QDate.currentDate().toString(Qt.ISODate)
                ) if addDateToExport else ""
     filename = QUrl(directoryURL).toLocalFile() + (
         QDir.separator() + fileName + dateStr + ".csv").replace(" ", "_")
     file = QSaveFile(filename)
     file.open(QIODevice.WriteOnly)
     file.write(
         QByteArray(
             bytearray("x,y,z,phi (°),theta (°),moment (mu_B)\n", 'utf-8')))
     for dip in dipoles:
         angles = anglesQuaternionToSph(dip.quaternion)
         line = str(dip.position.x()) + "," + str(
             dip.position.y()) + "," + str(dip.position.z()) + "," + str(
                 degrees(angles[0])) + "," + str(degrees(
                     angles[1])) + "," + str(dip.moment) + "\n"
         line = QByteArray(bytearray(line, 'utf-8'))
         file.write(line)
     file.commit()
     if (file.errorString() == "Unknown error"):
         return True
     else:
         return False
Example #4
0
    def __init__(self, format, durationUs, sampleRate, parent):
        super(Generator, self).__init__(parent)

        self.m_pos = 0
        self.m_buffer = QByteArray()

        self.generateData(format, durationUs, sampleRate)
Example #5
0
 def to_base64(self, w=32, h=32):
     """Return icon as base64 to make it work with html"""
     pix = self.pixmap(w, h)
     data = QByteArray()
     buff = QBuffer(data)
     pix.save(buff, "PNG")
     return data.toBase64().data().decode()
Example #6
0
    def testIt(self):
        w = QGLWidget()
        w.makeCurrent()

        b = QGLBuffer()
        b.setUsagePattern(QGLBuffer.DynamicDraw)

        self.assertTrue(b.create())
        self.assertTrue(b.bufferId() != 0)
        self.assertTrue(b.bind())

        data = QByteArray(py3k.b("12345"))
        b.allocate(data)
        self.assertEqual(b.size(), data.size())

        m = b.map(QGLBuffer.ReadOnly)
        if m:
            self.assertEqual(m, py3k.buffer(py3k.b(data.data())))
            b.unmap()

            m = b.map(QGLBuffer.ReadWrite)
            m[3] = py3k.b('A')[0]
            b.unmap()
            result, rdata = b.read(3, 1)
            self.assertTrue(result)
            self.assertEqual(py3k.b('A'), rdata.data())
        else:
            print(" memory mapping is not possible in this OpenGL implementation.")
        b.release()
Example #7
0
    def _loadSettings(self):

        settings = QSettings()

        # Recent documents
        size = settings.beginReadArray("RecentDocuments")
        for idx in range(size-1, -1, -1):
            settings.setArrayIndex(idx)
            canonicalName = QFileInfo(settings.value("Document")).canonicalFilePath()
            self._updateRecentDocuments(canonicalName)
        settings.endArray()

        # Application properties: Geometry
        geometry = settings.value("Application/Geometry", QByteArray()) if self._preferences.restoreApplicationGeometry() else QByteArray()
        if not geometry.isEmpty():
            self.restoreGeometry(geometry)
        else:
            availableGeometry = self.screen().availableGeometry()
            self.resize(availableGeometry.width() * 2/3, availableGeometry.height() * 2/3)
            self.move((availableGeometry.width() - self.width()) / 2, (availableGeometry.height() - self.height()) / 2)

        # Application properties: State
        state = settings.value("Application/State", QByteArray()) if self._preferences.restoreApplicationState() else QByteArray()
        if not state.isEmpty():
            self.restoreState(state)
        else:
            self._toolbarApplication.setVisible(True)
            self._toolbarDocument.setVisible(True)
            self._toolbarEdit.setVisible(True)
            self._toolbarTools.setVisible(True)
            self._toolbarView.setVisible(False)
            self._toolbarHelp.setVisible(False)
Example #8
0
    def testVoidPtr(self):
        # Creating a VoidPtr object requires an address of
        # a C++ object, a wrapped Shiboken Object type,
        # an object implementing the Python Buffer interface,
        # or another VoidPtr object.

        # Original content
        b = b"Hello world"
        ba = QByteArray(b)
        vp = VoidPtr(ba, ba.size())
        self.assertIsInstance(vp, shiboken.VoidPtr)

        # Create QByteArray from voidptr byte interpretation
        nba = QByteArray.fromRawData(vp.toBytes())
        # Compare original bytes to toBytes()
        self.assertTrue(b, vp.toBytes())
        # Compare original with new QByteArray data
        self.assertTrue(b, nba.data())
        # Convert original and new to str
        self.assertTrue(str(b), str(nba))

        # Modify nba through a memoryview of vp
        mv = memoryview(vp)
        self.assertFalse(mv.readonly)
        mv[6:11] = b'void*'
        self.assertEqual(str(ba), str(b"Hello void*"))
    def testSliceAssignmentByteArray(self):
        b = QByteArray(py3k.b('0123456789'))
        # replace
        b[2:8] = bytearray(py3k.b('abcdef'))
        self.assertEqual(b[2:8], py3k.b('abcdef'))
        # shrink
        b[2:8] = bytearray(py3k.b('aaa'))
        self.assertEqual(b, py3k.b('01aaa89'))
        # expanse
        b[2:5] = bytearray(py3k.b('uvwxyz'))
        self.assertEqual(b, py3k.b('01uvwxyz89'))
        # Delete behavior
        b[2:8] = bytearray(py3k.b(''))
        self.assertEqual(b, py3k.b('0189'))

        b = QByteArray(py3k.b('0123456789'))
        # reverse assginment
        b[5:2:-1] = bytearray(py3k.b('ABC'))
        self.assertEqual(b, py3k.b('012CBA6789'))
        # step is not 1
        b[2:9:3] = bytearray(py3k.b('XYZ'))
        self.assertEqual(b, py3k.b('01XCBY67Z9'))
        b = QByteArray(py3k.b('0123456789'))
        b[9:2:-3] = bytearray(py3k.b('XYZ'))
        self.assertEqual(b, py3k.b('012Z45Y78X'))
    def testQByteArrayValid(self):
        '''QDataStream <<>> QByteArray - valid'''
        self.stream << QByteArray("hello")

        res = QByteArray()

        self.read_stream >> res
        self.assertEqual(res, QByteArray("hello"))
Example #11
0
 def load_finished(self, state):
     pixmap = self.engine.grab()
     self.image = QByteArray()
     buf = QBuffer(self.image)
     buf.open(QIODevice.WriteOnly)
     pixmap.save(buf, "PNG")
     buf.close()
     self.quit()
Example #12
0
 def roleNames(self) -> typing.Dict:
     """Returns dict with role numbers and role names for default and custom roles together"""
     # Append custom roles to the default roles and give them names for a usage in the QML
     roles = super().roleNames()
     roles[self.Roles.LOCATION.value] = QByteArray(b'location')
     roles[self.Roles.ID.value] = QByteArray(b'id')
     print(roles)
     return roles
Example #13
0
    def roleNames(self):

        roles = {
            UserModel.RoleName: QByteArray(b'name'),
            UserModel.RoleActive: QByteArray(b'active')
        }

        return roles
Example #14
0
    def run(self):
        # Try to connect to an incomming tcp socket using its socket descriptor
        tcpSocket = QTcpSocket()
        if not tcpSocket.setSocketDescriptor(self.socketDescriptor):
            FreeCAD.Console.PrintError("Socket not accepted.\n")
            return

        # Wait for an incomming message
        if not tcpSocket.waitForReadyRead(msecs=WAIT_TIME_MS):
            FreeCAD.Console.PrintError("No request send.\n")
            return

        # Make an input data stream
        instr = QDataStream(tcpSocket)
        instr.setVersion(QDataStream.Qt_4_0)

        # Try to read the message size
        if self.blockSize == 0:
            if tcpSocket.bytesAvailable() < 2:
                return
            self.blockSize = instr.readUInt16()

        # Check message is sent complete
        if tcpSocket.bytesAvailable() < self.blockSize:
            return

        # Read message and inform about it
        instr = instr.readString()
        FreeCAD.Console.PrintLog("CommandServer received> " + str(instr) +
                                 "\n")

        # Try to execute the message string and prepare  a response
        try:
            exec(str(instr))
        except Exception as e:
            FreeCAD.Console.PrintError("Executing external command failed:" +
                                       str(e) + "\n")
            message = "Command failed - " + str(e)
        else:
            FreeCAD.Console.PrintLog("Executing external command succeded!\n")
            message = COMMAND_EXECUTED_CONFIRMATION_MESSAGE

        # Prepare the data block to send back and inform about it
        FreeCAD.Console.PrintLog("CommandServer sending> " + message + " \n")
        block = QByteArray()
        outstr = QDataStream(block, QIODevice.WriteOnly)
        outstr.setVersion(QDataStream.Qt_4_0)
        outstr.writeUInt16(0)
        outstr.writeQString(message)
        outstr.device().seek(0)
        outstr.writeUInt16(block.size() - 2)

        # Send the block, disconnect from the socket and terminate the QThread
        tcpSocket.write(block)
        tcpSocket.disconnectFromHost()
        tcpSocket.waitForDisconnected()
Example #15
0
    def testQByteArrayNull(self):
        '''QDataStream <<>> QByteArray - null'''
        self.stream << QByteArray()

        res = QByteArray()

        self.read_stream >> res
        self.assertEqual(res, QByteArray())
        self.assertTrue(res.isEmpty())
        self.assertTrue(res.isNull())
Example #16
0
 def testReader(self):
     ba = QByteArray()
     writer = QCborStreamWriter(ba)
     writer.append(42)
     del writer
     self.assertTrue(not ba.isEmpty())
     reader = QCborStreamReader(ba)
     self.assertTrue(reader.hasNext())
     value = reader.toInteger()
     self.assertEqual(value, 42)
Example #17
0
    def testQByteArrayEmpty(self):
        '''QDataStream <<>> QByteArray - empty'''
        self.stream << QByteArray("")

        res = QByteArray()

        self.read_stream >> res
        self.assertEqual(res, QByteArray(""))
        self.assertTrue(res.isEmpty())
        self.assertFalse(res.isNull())
    def testRawData(self):
        data = QDataStream()
        self.assertEqual(data.readRawData(4), None)

        ba = QByteArray()
        data = QDataStream(ba, QIODevice.WriteOnly)
        data.writeRawData('AB\x00C')
        self.assertEqual(ba.data(), py3k.b('AB\x00C'))

        data = QDataStream(ba)
        self.assertEqual(data.readRawData(4), py3k.b('AB\x00C'))
Example #19
0
    def readData(self, maxlen):
        data = QByteArray()
        total = 0

        while maxlen > total:
            chunk = min(self.m_buffer.size() - self.m_pos, maxlen - total)
            data.append(self.m_buffer.mid(self.m_pos, chunk))
            self.m_pos = (self.m_pos + chunk) % self.m_buffer.size()
            total += chunk

        return data.data()
Example #20
0
    def testRawData(self):
        data = QDataStream()
        self.assertEqual(data.readRawData(4), None)

        ba = QByteArray()
        data = QDataStream(ba, QIODevice.WriteOnly)
        data.writeRawData('AB\x00C')
        self.assertEqual(ba.data(), py3k.b('AB\x00C'))

        data = QDataStream(ba)
        self.assertEqual(data.readRawData(4), py3k.b('AB\x00C'))
Example #21
0
    def readData(self, maxlen):
        data = QByteArray()
        total = 0

        while maxlen > total:
            chunk = min(self.m_buffer.size() - self.m_pos, maxlen - total)
            data.append(self.m_buffer.mid(self.m_pos, chunk))
            self.m_pos = (self.m_pos + chunk) % self.m_buffer.size()
            total += chunk

        return data.data()
Example #22
0
def encode_image(image: QImage) -> str:
    image_bytes = QByteArray()
    buffer = QBuffer(image_bytes)
    buffer.open(QIODevice.WriteOnly)

    # writes pixmap into bytes in PNG format
    image.save(buffer, "PNG")  # type: ignore
    encoded_bytes = image_bytes.toBase64()
    codec = QTextCodec.codecForName(b"UTF-8")
    encoded_string = codec.toUnicode(encoded_bytes)
    return encoded_string
Example #23
0
	def preparar_favicon(self, url):
		try:
			archivo_ico = backend.descargar_favico(url)
		except Exception:  # Si lo que se ingreso era un link pero no se consiguio favicon
			with open("media/favicons/domain.ico") as ico:
				return QByteArray(ico.read())
		# Si no se consiguio la imagen
		if archivo_ico is None:
			return None
		with open(archivo_ico, "rb") as ico:
			return QByteArray(ico.read())
Example #24
0
    def __init__(self, model, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.model = model

        # Inicializace socketu
        self.socket = QTcpSocket(self)
        self.socket.readyRead.connect(self.read)
        self.socket.stateChanged.connect(self.socketStateChanged)

        # Příprava pro čtení dat
        self.readBuffer = QByteArray()
        self.textCodec = QTextCodec.codecForName("UTF-8")
Example #25
0
 def testSetNum(self):
     b = QByteArray()
     b.setNum(py3k.long(-124124))
     self.assertEqual(b, "-124124")
     b = QByteArray()
     b.setNum(-124124)
     self.assertEqual(b, "-124124")
     b = QByteArray()
     b.setNum(-0.5)
     self.assertEqual(b, "-0.5")
    def run(self):
        self.mutex.lock()
        serverName = self.hostName
        serverPort = self.port
        self.mutex.unlock()

        while not self.quit:
            Timeout = 5 * 1000

            socket = QTcpSocket()
            socket.connectToHost(serverName, serverPort)

            if not socket.waitForConnected(Timeout):
                self.error.emit(socket.error(), socket.errorString())
                return

            while socket.bytesAvailable() < 2:
                if not socket.waitForReadyRead(Timeout):
                    self.error.emit(socket.error(), socket.errorString())
                    return

            instr = QDataStream(socket)
            instr.setVersion(QDataStream.Qt_4_0)
            blockSize = instr.readUInt16()

            block = QByteArray()
            outstr = QDataStream(block, QIODevice.WriteOnly)
            outstr.setVersion(QDataStream.Qt_4_0)

            

            while socket.bytesAvailable() < blockSize:
                if not socket.waitForReadyRead(Timeout):
                    self.error.emit(socket.error(), socket.errorString())
                    return

            self.mutex.lock()
            outstr.writeUInt16(0)
            outstr.writeQString("Message to Server")
            outstr.device().seek(0)
            outstr.writeUInt16(block.size() - 2)
            socket.write(block)
#            socket.write(block)
            fortune = instr.readQString()
            self.newFortune.emit(fortune)

            self.cond.wait(self.mutex)
            serverName = self.hostName
            serverPort = self.port
            self.mutex.unlock()
Example #27
0
    def send_file(self):
        self._transaction.set_status(TransactionStatus.SENDING)
        file_to_byte_array = QByteArray()
        data = QByteArray()
        stream = QDataStream(data, QIODevice.WriteOnly)

        QFile.open(self._file, QIODevice.ReadOnly)
        stream.writeUInt32(0)
        stream.writeString(self._file_name)
        print("size of name ", getsizeof(self._file_name))
        file_to_byte_array = self._file.readAll()
        data.append(file_to_byte_array)
        self._file.close()

        stream.device().seek(0)
        stream.writeUInt32(data.size() - getsizeof(self._file_name))
        print("total  ", data.size() - getsizeof(self._file_name))

        x = 0
        while (x < data.size()):
            y = self._socket.write(data)
            print("poslato  ", y)
            x += y
            print("x  ", x)
        self._transaction.set_status(TransactionStatus.FINISHED)
Example #28
0
    def RecieveData(self):
        #self.CommandSocket.receiveDatagram(20)
        HEADER = QByteArray()
        HEADER.resize(2)
        if self.bytesAvailable < self.LimitBufferSize - self.MaxTransferUnit:  #check that memory for packet available
            if self.BufferWrite.pos(
            ) < self.LimitBufferSize - self.MaxTransferUnit:
                (newData, sender,
                 senderPort) = self.CommandSocket.readDatagram(20)

                #newData = self.CommandSocket.read(self.LimitBufferSize - self.bytesAvailable)
                #print("   NEW DATA - ",newData.toHex(),"to POS - ",self.BufferWrite.pos())
                self.BufferWrite.write(newData)
                self.bytesAvailable += newData.size()
                print(self.Timer.restart())
                #print("REC ",data)
                #print("   BUFFER - ",self.BufferWrite.data().toHex())

            else:
                H1 = 0
                H2 = 0
                while self.CommandSocket.bytesAvailable() > 0:
                    H1 = H2
                    H2 = self.SocketDataStream.readInt16()

                    if H1 == 0xF1 and (H2 == 0xD1 or H2 == 0xD2 or H2 == 0xD3
                                       or H2 == 0xC1):
                        self.BufferWrite.seek(0)
                        newData = self.CommandSocket.read(
                            self.LimitBufferSize - self.bytesAvailable)
                        self.WriteDataStream.writeInt16(H1)
                        self.WriteDataStream.writeInt16(H2)
                        print(
                            "=============================================================="
                        )
                        print("SEEK TO 0")
                        print("NEW DATA - ", newData, "to POS - ",
                              self.BufferWrite.pos() - 4)
                        self.BufferWrite.write(newData)
                        self.bytesAvailable += (4 + newData.size())
                        #print("BUFFER - ",self.NetworkDataArray.toHex())
                        break
                    else:
                        self.WriteDataStream.writeInt16(H2)
                        self.bytesAvailable += 1

        #self.SignalDataRec.emit("BYTES IN REC BUFFER - " + str(self.bytesAvailable))

        if (self.bytesAvailable >= self.MinTransferUnit):
            self.SignalFrameDataAvailable.emit()
Example #29
0
    def testPastEnd(self):
        '''QDataStream >> QBitArray reading past the end of the data'''
        data = []

        data.append((QByteArray(), QDataStream.ReadPastEnd, QBitArray()))
        data.append(
            (QByteArray(py3k.b('\x00')), QDataStream.ReadPastEnd, QBitArray()))
        data.append((QByteArray(py3k.b('\x00\x00')), QDataStream.ReadPastEnd,
                     QBitArray()))
        data.append(
            (QByteArray(py3k.b('\x00\x00\x00')), QDataStream.ReadPastEnd,
             QBitArray()))
        data.append(
            (QByteArray(py3k.b('\x00\x00\x00\x01')), QDataStream.ReadPastEnd,
             QBitArray()))
        data.append(
            (QByteArray(py3k.b('\x00\x00\x00\x02')), QDataStream.ReadPastEnd,
             QBitArray()))
        data.append(
            (QByteArray(py3k.b('\x00\x00\x00\x03')), QDataStream.ReadPastEnd,
             QBitArray()))
        data.append(
            (QByteArray(py3k.b('\x00\x00\x00\x04')), QDataStream.ReadPastEnd,
             QBitArray()))

        self._check_bitarray(data)
    def process_metadata_txt(self, repo: Addon, data: QtCore.QByteArray):
        """Process the metadata.txt metadata file"""
        self.status_message.emit(
            translate("AddonsInstaller", "Downloaded metadata.txt for {}").format(
                repo.display_name
            )
        )
        f = io.StringIO(data.data().decode("utf8"))
        while True:
            line = f.readline()
            if not line:
                break
            if line.startswith("workbenches="):
                depswb = line.split("=")[1].split(",")
                for wb in depswb:
                    wb_name = wb.strip()
                    if wb_name:
                        repo.requires.add(wb_name)
                        FreeCAD.Console.PrintLog(
                            f"{repo.display_name} requires FreeCAD Addon '{wb_name}'\n"
                        )

            elif line.startswith("pylibs="):
                depspy = line.split("=")[1].split(",")
                for pl in depspy:
                    dep = pl.strip()
                    if dep:
                        repo.python_requires.add(dep)
                        FreeCAD.Console.PrintLog(
                            f"{repo.display_name} requires python package '{dep}'\n"
                        )

            elif line.startswith("optionalpylibs="):
                opspy = line.split("=")[1].split(",")
                for pl in opspy:
                    dep = pl.strip()
                    if dep:
                        repo.python_optional.add(dep)
                        FreeCAD.Console.PrintLog(
                            f"{repo.display_name} optionally imports python package"
                            + f" '{pl.strip()}'\n"
                        )
        # For review and debugging purposes, store the file locally
        package_cache_directory = os.path.join(self.store, repo.name)
        if not os.path.exists(package_cache_directory):
            os.makedirs(package_cache_directory)
        new_xml_file = os.path.join(package_cache_directory, "metadata.txt")
        with open(new_xml_file, "wb") as f:
            f.write(data.data())
Example #31
0
    def QImageToBase64(image: QImage,
                       format: str = "jpeg",
                       width: int = 1080,
                       with_header: bool = True) -> str:
        byte_array = QByteArray()
        buffer = QBuffer(byte_array)
        image.scaledToWidth(width).save(buffer, format)

        result = ""
        if with_header:
            result += "data:image/%s;base64," % format

        result += str(byte_array.toBase64())[2:-1]

        return result
Example #32
0
    def setUp(self):
        self.dom = QDomDocument()

        self.goodXmlData = QByteArray('''
        <typesystem package="PySide2.QtXml">
            <value-type name="QDomDocument"/>
            <value-type name="QDomElement"/>
        </typesystem>
        ''')

        self.badXmlData = QByteArray('''
        <typesystem package="PySide2.QtXml">
            <value-type name="QDomDocument">
        </typesystem>
        ''')
Example #33
0
    def __init__(self, parent=None):
        super(NetworkConnectionClass, self).__init__(parent=parent)
        #self.CommandSocket = QTcpSocket()
        self.CommandSocket = QUdpSocket()
        self.CommandSocket.bind(QHostAddress("192.168.100.2"), 2323)
        self.CommandSocket.connected.connect(self.EventConnectedHandle)
        self.CommandSocket.readyRead.connect(self.RecieveData)

        #self.CommandSocket.connectToHost("192.168.100.5",2323,QIODevice.ReadWrite)
        #self.CommandSocket.connectToHost("127.0.0.1",2323,QIODevice.ReadWrite)
        #self.CommandSocket.connectToHost("192.168.20.196",2323,QIODevice.ReadWrite)
        #print("NETWORK - ",self.CommandSocket.localAddress(),self.CommandSocket.peerAddress())

        self.Display = WindowNetworkConnection()

        self.NetworkDataArray = QByteArray()
        self.NetworkDataArray.resize(2000)
        self.SignalDataRec.connect(self.Display.PrintData)

        self.BufferWrite = QBuffer(self.NetworkDataArray)
        self.BufferWrite.open(QBuffer.WriteOnly)

        self.BufferRead = QBuffer(self.NetworkDataArray)
        self.BufferRead.open(QBuffer.ReadOnly)

        self.ReadDataStream = QDataStream(self.BufferRead)
        self.ReadDataStream.setByteOrder(QDataStream.LittleEndian)

        self.WriteDataStream = QDataStream(self.BufferWrite)
        self.WriteDataStream.setByteOrder(QDataStream.LittleEndian)

        self.SocketDataStream = QDataStream(self.CommandSocket)
        self.SocketDataStream.setByteOrder(QDataStream.LittleEndian)

        self.Timer = QTime()
        self.Timer.start()

        self.BufferRead.seek(0)
        self.BufferWrite.seek(0)

        self.LimitBufferSize = 2000
        self.MinTransferUnit = 7
        self.MaxTransferUnit = 18
        self.bytesAvailable = 0
        self.Display.ui.pushButton.clicked.connect(self.SendData)

        #===================================================== WRITE BUFFER
        self.SendBuffer = QByteArray()
Example #34
0
    def __init__(self, format, durationUs, sampleRate, parent):
        super(Generator, self).__init__(parent)

        self.m_pos = 0
        self.m_buffer = QByteArray()

        self.generateData(format, durationUs, sampleRate)
Example #35
0
 def findIcons(self):
     if hou.applicationVersion()[0] < 15:
         for category in os.listdir(self.path):
             for ico in os.listdir(os.path.join(self.path, category)):
                 iconPath = os.path.join(
                     os.path.join(self.path, category, ico))
                 iconName = '_'.join([category, os.path.splitext(ico)[0]])
                 self.icons[iconName] = QPixmap(iconPath)
     else:
         zf = zipfile.ZipFile(self.path, 'r')
         for f in zf.namelist():
             if f.startswith('old'): continue
             if os.path.splitext(f)[-1] == '.svg':
                 svg = QSvgRenderer(QByteArray(zf.read(f)))
                 if not svg.isValid():
                     continue
                 pixmap = QPixmap(iconSize, iconSize)
                 painter = QPainter()
                 painter.begin(pixmap)
                 pixmap.fill(QColor(Qt.black))
                 svg.render(painter)
                 painter.end()
                 category, ico = f.split('/')
                 iconName = '_'.join([category, os.path.splitext(ico)[0]])
                 self.icons[iconName] = pixmap
         zf.close()
Example #36
0
 def testConcatPythonStringAndQByteArray(self):
     #Test concatenation of a Python string with a QByteArray, in this order
     concat_python_string_add_qbytearray_worked = True
     qba = QByteArray('foo')
     result = 'bar\x00' + qba
     self.assertEqual(type(result), QByteArray)
     self.assertEqual(result, 'bar\x00foo')
Example #37
0
 def refresh(self, defaultviewsize=False):
     xml = self.getSvgXML()
     svg_ba = QByteArray(bytes(xml, 'utf-8'))
     self.load(svg_ba)
     if defaultviewsize:
         #  This will make sure diagram is shown full scale.
         self.resize(self.sizeHint())
    def run(self):
        tcpSocket = QTcpSocket()
        if not tcpSocket.setSocketDescriptor(self.socketDescriptor):
            self.error.emit(tcpSocket.error())
            return

        block = QByteArray()
        outstr = QDataStream(block, QIODevice.WriteOnly)
        outstr.setVersion(QDataStream.Qt_4_0)
        outstr.writeUInt16(0)
        outstr.writeQString(self.text)
        outstr.device().seek(0)
        outstr.writeUInt16(block.size() - 2)

        tcpSocket.write(block)
        tcpSocket.disconnectFromHost()
        tcpSocket.waitForDisconnected()
Example #39
0
 def testToNumberFloat(self):
     obj = QByteArray('37.109')
     self.assertEqual((ctypes.c_float(37.109).value, True),
                      obj.toFloat())
 def testNullStrings(self):
     ba = QByteArray('\x00')
     self.assertEqual(ba.at(0), '\x00')
     self.assertEqual(ba[0], py3k.b('\x00'))
Example #41
0
class Generator(QIODevice):

    def __init__(self, format, durationUs, sampleRate, parent):
        super(Generator, self).__init__(parent)

        self.m_pos = 0
        self.m_buffer = QByteArray()

        self.generateData(format, durationUs, sampleRate)

    def start(self):
        self.open(QIODevice.ReadOnly)

    def stop(self):
        self.m_pos = 0
        self.close()

    def generateData(self, format, durationUs, sampleRate):
        pack_format = ''

        if format.sampleSize() == 8:
            if format.sampleType() == QAudioFormat.UnSignedInt:
                scaler = lambda x: ((1.0 + x) / 2 * 255)
                pack_format = 'B'
            elif format.sampleType() == QAudioFormat.SignedInt:
                scaler = lambda x: x * 127
                pack_format = 'b'
        elif format.sampleSize() == 16:
            if format.sampleType() == QAudioFormat.UnSignedInt:
                scaler = lambda x: (1.0 + x) / 2 * 65535
                pack_format = '<H' if format.byteOrder() == QAudioFormat.LittleEndian else '>H'
            elif format.sampleType() == QAudioFormat.SignedInt:
                scaler = lambda x: x * 32767
                pack_format = '<h' if format.byteOrder() == QAudioFormat.LittleEndian else '>h'

        assert(pack_format != '')

        channelBytes = format.sampleSize() // 8
        sampleBytes = format.channelCount() * channelBytes

        length = (format.sampleRate() * format.channelCount() * (format.sampleSize() // 8)) * durationUs // 100000

        self.m_buffer.clear()
        sampleIndex = 0
        factor = 2 * pi * sampleRate / format.sampleRate()

        while length != 0:
            x = sin((sampleIndex % format.sampleRate()) * factor)
            packed = pack(pack_format, int(scaler(x)))

            for _ in range(format.channelCount()):
                self.m_buffer.append(packed)
                length -= channelBytes

            sampleIndex += 1

    def readData(self, maxlen):
        data = QByteArray()
        total = 0

        while maxlen > total:
            chunk = min(self.m_buffer.size() - self.m_pos, maxlen - total)
            data.append(self.m_buffer.mid(self.m_pos, chunk))
            self.m_pos = (self.m_pos + chunk) % self.m_buffer.size()
            total += chunk

        return data.data()

    def writeData(self, data):
        return 0

    def bytesAvailable(self):
        return self.m_buffer.size() + super(Generator, self).bytesAvailable()
Example #42
0
 def testToNumberUShort(self):
     obj = QByteArray('37')
     self.assertEqual((37, True), obj.toUShort())
Example #43
0
 def testIt(self):
     data = py3k.b("foobar")
     a = QByteArray.fromRawData(data)
     self.assertEqual(type(a), QByteArray)
     self.assertEqual(a.data(), data)
Example #44
0
 def testToNumberDouble(self):
     obj = QByteArray('37.109')
     self.assertEqual((ctypes.c_double(37.109).value, True),
                      obj.toDouble())
Example #45
0
 def testAppend(self):
     b = QByteArray()
     b.append("A")
     self.assertEqual(b.size(), 1)
     b.append("AB")
     self.assertEqual(b.size(), 3)
Example #46
0
 def testPathSeparator(self):
     #QByteArray.split('/')
     obj = QByteArray(unittest.__file__)
     self.assertEqual(obj.split('/'), unittest.__file__.split('/'))
Example #47
0
 def testData(self):
     url = QByteArray("http://web.openbossa.org/")
     self.assertEqual(url.data(), py3k.b("http://web.openbossa.org/"))
Example #48
0
 def testDataWithZeros(self):
     s1 = "123\000321"
     ba = QByteArray(s1)
     s2 = ba.data()
     self.assertEqual(py3k.b(s1), s2)
     self.assertEqual(s1, ba)