def testQByteArrayValid(self):
'''QDataStream <<>> QByteArray - valid'''
self.stream << QByteArray("hello")
res = QByteArray()
self.read_stream >> res
self.assertEqual(res, QByteArray("hello"))
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())
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 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 from_hash(cls, hash):
u = User(hash['identifier'], hash['name'])
u.image = QImage.fromData(QByteArray(
hash['picture_bytes'].data)).scaledToHeight(128)
#u.image = None
return u
f = open(hash['picture_bytes'], "rb")
bytes = f.read(-1)
f.close()
u.image = QImage.fromData(QByteArray(bytes)).scaledToHeight(256)
return u
def setUp(self):
self.dom = QDomDocument()
self.goodXmlData = QByteArray('''
<typesystem package="PySide.QtXml">
<value-type name="QDomDocument"/>
<value-type name="QDomElement"/>
</typesystem>
''')
self.badXmlData = QByteArray('''
<typesystem package="PySide.QtXml">
<value-type name="QDomDocument">
</typesystem>
''')
def open(self, address, method='get', headers={}, auth=None, body=None,
default_popup_response=None):
"""Opens a web page.
:param address: The resource URL.
:param method: The Http method.
:param headers: An optional dict of extra request hearders.
:param auth: An optional tuple of HTTP auth (username, password).
:param body: An optional string containing a payload.
:param default_popup_response: the default response for any confirm/
alert/prompt popup from the Javascript (replaces the need for the with
blocks)
:return: Page resource, All loaded resources.
"""
body = body or QByteArray()
try:
method = getattr(QNetworkAccessManager,
"%sOperation" % method.capitalize())
except AttributeError:
raise Error("Invalid http method %s" % method)
request = QNetworkRequest(QUrl(address))
request.CacheLoadControl(0)
for header in headers:
request.setRawHeader(header, headers[header])
self._auth = auth
self._auth_attempt = 0 # Avoids reccursion
self.main_frame.load(request, method, body)
self.loaded = False
if default_popup_response is not None:
Ghost._prompt_expected = (default_popup_response, None)
Ghost._confirm_expected = (default_popup_response, None)
return self.wait_for_page_loaded()
def image(self):
if self._image_as_pixmap is None and self.picture_data:
# Caution ! QImage and stuff work only if QApplication has been initialized !
image = QImage.fromData(QByteArray(self.picture_data))
self._image_as_pixmap = QPixmap.fromImage(image.convertToFormat(QImage.Format_RGB16, Qt.MonoOnly).scaledToHeight(128))
return self._image_as_pixmap
def testInRange(self):
#QByteArray[x] where x is a valid index
string = 'abcdefgh'
obj = QByteArray(string)
for i in range(len(string)):
self.assertEqual(obj[i], py3k.b(string[i]))
def test_connection(self):
self.message.setText(
'<span style="font-size: 10px; color: #000000;">' +
'Verbindung wird getestet.' + '</span>')
self.nam.finished.connect(self.test_reply)
self.nam.sslErrors.connect(self.ssl_errors)
ssl_config = QSslConfiguration().defaultConfiguration()
ssl_config.setCiphers(QSslSocket().supportedCiphers())
if self.certificate:
certificate = QSslCertificate(encoded=self.certificate,
format=QSsl.Pem)
ssl_config.setCaCertificates([certificate])
else:
ssl_config.setCaCertificates([])
url = QUrl(self.url_edit.text())
url.setPath("/".join(
filter(bool, (url.path() + "/ajax/read.php").split("/"))))
request = QNetworkRequest(url)
request.setSslConfiguration(ssl_config)
request.setRawHeader(
"Authorization", "Basic ".encode('utf-8') + b64encode(
(self.username_edit.text() + ":" +
self.password_edit.text()).encode('utf-8')))
request.setHeader(QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
self.replies.add(self.nam.post(request, QByteArray()))
def sendReply(self, action, *args, **kwargs):
try:
if hasattr(self, "socket"):
reply = QByteArray()
stream = QDataStream(reply, QIODevice.WriteOnly)
stream.setVersion(QDataStream.Qt_4_2)
stream.writeUInt32(0)
stream.writeQString(action)
for arg in args:
if isinstance(arg, int):
stream.writeInt(int(arg))
elif isinstance(arg, str):
stream.writeQString(arg)
elif isinstance(arg, list):
stream.writeQString(str(arg))
#stream << action << options
stream.device().seek(0)
stream.writeUInt32(reply.size() - 4)
self.socket.write(reply)
# else :
# # no socket !?
# self.quit()
except:
self.log.exception("Something awful happened when sending reply !")
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')
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()
def testIt(self):
if not py3k.IS_PY3K:
ba = QByteArray('1234567890')
self.assertEqual(ba[2:4], '34')
self.assertEqual(ba[:4], '1234')
self.assertEqual(ba[4:], '567890')
self.assertEqual(len(ba[4:1]), 0)
def testInRangeReverse(self):
#QByteArray[x] where x is a valid index (reverse order)
string = 'abcdefgh'
obj = QByteArray(string)
for i in range(len(string) - 1, 0, -1):
self.assertEqual(obj[i], py3k.b(string[i]))
def preparePacket(self, action, *args, **kwargs):
reply = QByteArray()
stream = QDataStream(reply, QIODevice.WriteOnly)
stream.setVersion(QDataStream.Qt_4_2)
stream.writeUInt32(0)
stream.writeQString(action)
for arg in args:
if type(arg) is LongType:
stream.writeQString(str(arg))
elif type(arg) is IntType:
stream.writeInt(arg)
elif isinstance(arg, basestring):
stream.writeQString(arg)
elif type(arg) is StringType:
stream.writeQString(arg)
elif type(arg) is FloatType:
stream.writeFloat(arg)
elif type(arg) is ListType:
stream.writeQString(str(arg))
stream.device().seek(0)
stream.writeUInt32(reply.size() - 4)
return reply
def setUp(self):
super(QPixmapQDatastream, self).setUp()
self.source_pixmap = QPixmap(100, 100)
self.source_pixmap.fill(Qt.red)
self.output_pixmap = QPixmap()
self.buffer = QByteArray()
self.read_stream = QDataStream(self.buffer, QIODevice.ReadOnly)
self.write_stream = QDataStream(self.buffer, QIODevice.WriteOnly)
def sendReply(self, action, *args, **kwargs):
try:
if hasattr(self, "socket"):
reply = QByteArray()
stream = QDataStream(reply, QIODevice.WriteOnly)
stream.setVersion(QDataStream.Qt_4_2)
stream.writeUInt32(0)
stream.writeQString(action)
for arg in args:
if type(arg) is LongType:
stream.writeQString(str(arg))
if type(arg) is IntType:
stream.writeInt(int(arg))
elif type(arg) is StringType:
stream.writeQString(arg)
elif isinstance(arg, basestring):
stream.writeQString(arg)
elif type(arg) is FloatType:
stream.writeFloat(arg)
elif type(arg) is ListType:
stream.writeQString(str(arg))
elif type(arg) is QFile:
arg.open(QIODevice.ReadOnly)
fileDatas = QByteArray(arg.readAll())
stream.writeInt32(fileDatas.size())
stream.writeRawData(fileDatas.data())
arg.close()
#stream << action << options
stream.device().seek(0)
stream.writeUInt32(reply.size() - 4)
self.socket.write(reply)
# else :
# # no socket !?
# self.quit()
except:
self.log.exception("Something awful happened when sending reply !")
def testCorruptData(self):
'''QDataStream reading corrupt data'''
data = []
data.append((QByteArray('\x00\x00\x00\x01\x02'),
QDataStream.ReadCorruptData,
QBitArray()))
self._check_bitarray(data)
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'))
def perform(self, url, method='GET', post_data=dict()):
request = self._make_request(url)
if method == 'GET':
self.web_view.load(request)
else:
encoded_data = self._urlencode_post_data(post_data)
request.setRawHeader(
'Content-Type',
QByteArray('application/x-www-form-urlencoded'))
self.web_view.load(request, QNetworkAccessManager.PostOperation,
encoded_data)
def image(self,pixmap):
if pixmap == None:
self._image_as_pixmap = None
self.picture_data = None
else:
byte_array = QByteArray()
qbuffer = QBuffer(byte_array)
qbuffer.open(QIODevice.WriteOnly)
pixmap.toImage().save(qbuffer, "PNG")
self._image_as_pixmap = None
self.picture_data = memoryview(byte_array.data()) # memory view to support python 2 and 3
def __init__(self, file_path, qimage=None):
file_name = os.path.basename(file_path)
self.src_file_path = file_path
super(Image, self).__init__(name=file_name)
self.index = len(Image.instances)
Image.instances.append(self)
base, ext = os.path.splitext(file_path)
mime_suffix = ext.lower()[1:]
if mime_suffix == 'jpg':
mime_suffix = 'jpeg'
self.mime_type = 'image/{}'.format(mime_suffix)
# Need to write this out temporarily or permanently
# depending on resource_format
if qimage:
writer = QImageWriter(
file_path,
QByteArray(bytes(str(mime_suffix).encode("latin-1"))))
writer.write(qimage)
# delete the write to close file handle
del writer
if ExportSettings.resource_format == ResourceFormats.SOURCE:
if not qimage:
shutil.copy(file_path, ExportSettings.out_dir)
self.uri = file_name
else:
with open(file_path, 'rb') as f:
img_bytes = f.read()
# Remove the temp qimage because resource_format isn't source
if qimage:
os.remove(file_path)
if (ExportSettings.resource_format == ResourceFormats.BIN
or ExportSettings.file_format == 'glb'):
single_buffer = Buffer.instances[0]
buffer_end = len(single_buffer)
single_buffer.byte_str += img_bytes
self.buffer_view = BufferView(single_buffer, buffer_end)
# 4-byte-aligned
aligned_len = (len(img_bytes) + 3) & ~3
for i in range(aligned_len - len(img_bytes)):
single_buffer.byte_str += b'0'
if (ExportSettings.file_format == 'gltf' and
ExportSettings.resource_format == ResourceFormats.EMBEDDED):
self.uri = "data:application/octet-stream;base64," + base64.b64encode(
img_bytes).decode("latin-1")
def mapBytes(self, kode):
im = self.draw(kode)
if isinstance(kode, UKode):
qxm = pilfunc.pixmap2qt(im)
elif isinstance(kode, (BKode, SKode)):
qxm = pilfunc.bitmap2qt(im)
else:
raise ValueError
bts = QByteArray()
buffer = QBuffer(bts)
buffer.open(QIODevice.WriteOnly)
qxm.save(buffer, "png")
buffer.close()
return bts
def testLatin1(self):
'''QTextStream readLine for simple Latin1 strings'''
data = []
data.append((QByteArray(), []))
data.append((QByteArray('\n'), ['']))
data.append((QByteArray('\r\n'), ['']))
data.append((QByteArray('ole'), ['ole']))
data.append((QByteArray('ole\n'), ['ole']))
data.append((QByteArray('ole\r\n'), ['ole']))
data.append((QByteArray('ole\r\ndole\r\ndoffen'), ['ole', 'dole', 'doffen']))
self._check_data(data)
def __init__(self, devices=None, filename=None, parent=None):
QObject.__init__(self, parent)
self.pullTimer = QTimer(self)
self.buf = QByteArray()
self.devices = devices
self.device = QAudioDeviceInfo.defaultOutputDevice()
self.generator = None
self.audioOutput = None
self.output = None
self.fmt = QAudioFormat()
self.pullMode = False
self.dump = filename
self._label = SUSPEND_LABEL
self.initializeAudio()
def __init__(self, url, title=None, geometry=None, icon=None):
super(Browser, self).__init__()
self.setGeometry(*geometry)
self.setWindowTitle(title)
if icon:
pixmap = QtGui.QPixmap()
if type(icon) == tuple: # package, not filepath
img_data = pkgutil.get_data(*icon)
else:
with open(icon) as fh:
img_data = fh.read()
pixmap.loadFromData(QByteArray(img_data))
self.setWindowIcon(QtGui.QIcon(pixmap))
self.load(QUrl(url))
def new_picture(self):
dialog = QFileDialog()
if (dialog.exec_()):
filename = dialog.selectedFiles()[0]
# print "ok {}".format(filename)
f = open(filename,"rb")
bytes = f.read(-1)
f.close()
image = QImage.fromData(QByteArray(bytes))
if image:
# save as buffer(bytes)
pixmap = QPixmap.fromImage(image.convertToFormat(QImage.Format_RGB16, Qt.MonoOnly).scaledToHeight(128))
self.set_pixmap_as_icon(pixmap)
def svgImage(svgfile, file=None):
qs = QSvgWidget()
qs.load(svgfile)
qim = QPixmap.grabWidget(qs)
bts = QByteArray()
buffer = QBuffer(bts)
buffer.open(QIODevice.WriteOnly)
qim.save(buffer, "png")
bts = buffer.data().data()
buffer.close()
if type(file) == str:
assert os.path.splitext(file)[1].lower() == ".png"
with open(file, "bw") as f:
f.write(bts)
elif hasattr(file, 'write'):
file.write(bts)
else:
return bts
def testPastEnd(self):
'''QDataStream >> QBitArray reading past the end of the data'''
data = []
data.append((QByteArray(), QDataStream.ReadPastEnd, QBitArray()))
data.append((QByteArray('\x00'), QDataStream.ReadPastEnd, QBitArray()))
data.append(
(QByteArray('\x00\x00'), QDataStream.ReadPastEnd, QBitArray()))
data.append(
(QByteArray('\x00\x00\x00'), QDataStream.ReadPastEnd, QBitArray()))
data.append((QByteArray('\x00\x00\x00\x01'), QDataStream.ReadPastEnd,
QBitArray()))
data.append((QByteArray('\x00\x00\x00\x02'), QDataStream.ReadPastEnd,
QBitArray()))
data.append((QByteArray('\x00\x00\x00\x03'), QDataStream.ReadPastEnd,
QBitArray()))
data.append((QByteArray('\x00\x00\x00\x04'), QDataStream.ReadPastEnd,
QBitArray()))
self._check_bitarray(data)
