def send_end_of_transmission(self):
"""Send end of transmission packet"""
# prepare message in byte stream
msg = QtCore.QByteArray()
msg_stream = QtCore.QDataStream(msg, QtCore.QIODevice.WriteOnly)
msg_stream.writeInt64(message_ids["MSG_ID_EOT"])
# reset state
self.registered = False
# print responses
if self.verbose:
print(self.response)
try:
if self.verbose:
print("Sending EOT:", msg)
# send the message over the socket
self.socket.send(msg)
# get ACK before return
rcv_data = QtCore.QByteArray(self.socket.recv())
except zmq.error.ZMQError:
print("ZMQ Error - No ACK for EOT")
return
rcv_stream = QtCore.QDataStream(rcv_data, QtCore.QIODevice.ReadOnly)
r = rcv_stream.readInt64()
if r != message_ids["MSG_ID_EOT_ACK"]:
print("Did not receive ACK for EOT but: ", r)
else:
if self.verbose:
print("EOT success")
def send_request_for_features(self):
# prepare message in byte stream
msg = QtCore.QByteArray()
msg_stream = QtCore.QDataStream(msg, QtCore.QIODevice.WriteOnly)
msg_stream.writeInt64(message_ids["MSG_ID_FEATURE_REQ"])
try:
if self.verbose:
print("Send request for features message")
# send the message over the socket
self.socket.send(msg)
# get ACK before return
rcv = QtCore.QByteArray(self.socket.recv())
except zmq.error.ZMQError:
if self.verbose:
print("ZMQ Error")
return
rcv_stream = QtCore.QDataStream(rcv, QtCore.QIODevice.ReadOnly)
feats = []
for i in range(3):
feats.append(rcv_stream.readQStringList())
r = rcv_stream.readInt64()
if r == message_ids["MSG_ID_FEATURE_REQ_ACK"]:
if self.verbose:
print("Feature Request ACK")
else:
print("Feature Request failed!")
if len([i for sublist in feats for i in sublist]) == 0:
if self.verbose:
print("Feature Request List Empty")
feats = None
return feats
def handle_messages(self):
"""Handle messages from Shape-In
Please don't override this function. Use
:func:`ShapeLinkPlugin.handle_event` for your customized plugins.
"""
# read first byte
if self._first_call: # needed for accurate line_profiler tests
try:
# get message from socket
message = self.socket.recv()
rcv = QtCore.QByteArray(message)
except zmq.error.ZMQError:
if self.verbose:
print(" ZMQ Error - timed out")
return
self._first_call = False
else:
try:
# get message from socket
message = self.socket.recv()
rcv = QtCore.QByteArray(message)
except zmq.error.ZMQError:
if self.verbose:
print(" ZMQ Error - timed out")
return
rcv_stream = QtCore.QDataStream(rcv, QtCore.QIODevice.ReadOnly)
r = rcv_stream.readInt64()
send_data = QtCore.QByteArray()
send_stream = QtCore.QDataStream(send_data, QtCore.QIODevice.WriteOnly)
if r == message_ids["MSG_ID_FEATURE_REQ"]:
# Allow plugin to request features
self.run_features_request_message(send_stream)
elif r == message_ids["MSG_ID_REGISTER"]:
# register
self.run_register_message(rcv_stream, send_stream)
self.after_register()
elif r == message_ids["MSG_ID_EOT"]:
# End of Transmission (EOT) message
self.run_EOT_message(send_stream)
self.after_transmission()
elif r >= 0:
e = self.run_event_message(r, rcv_stream)
# pass event object to user-defined method
ret = self.handle_event(e)
send_stream.writeBool(ret)
else:
# unknown message
raise ValueError("Received unknown message header: {}".format(r))
self.socket.send(send_data)
def send_event(
self,
event_id: int,
scalar_values: np.array,
# vector of vector of short
vector_values: List[np.array],
image_values: List[np.array]) -> bool:
"""Send a single event to the other process"""
# prepare message in byte stream
msg = QtCore.QByteArray()
msg_stream = QtCore.QDataStream(msg, QtCore.QIODevice.WriteOnly)
msg_stream.writeInt64(event_id)
assert len(scalar_values) == self.scalar_len
assert len(vector_values) == self.vector_len
assert len(image_values) == self.image_len
assert np.issubdtype(scalar_values.dtype, np.floating)
if self.scalar_len > 0:
qstream_write_array(msg_stream, scalar_values)
if self.vector_len > 0:
msg_stream.writeUInt32(self.vector_len)
for e in vector_values:
assert e.dtype == np.int16, "fluorescence data is int16"
qstream_write_array(msg_stream, e)
if self.image_len > 0:
msg_stream.writeUInt32(self.image_len)
for (im_name, e) in zip(self.image_names, image_values):
if im_name == "mask":
assert e.dtype == np.bool_, "'mask' data is bool"
else:
assert e.dtype == np.uint8, "'image' data is uint8"
qstream_write_array(msg_stream, e.flatten())
try:
# send the message over the socket
self.socket.send(msg)
# get ACK before return
rcv_data = QtCore.QByteArray(self.socket.recv())
except zmq.error.ZMQError:
if self.verbose:
print("ZMQ Error")
return
rcv_stream = QtCore.QDataStream(rcv_data, QtCore.QIODevice.ReadOnly)
self.response.append(rcv_stream.readBool())
return self.response[-1]
def writeFile(self, fileName):
file = QtCore.QFile(fileName)
if not file.open(QtCore.QIODevice.WriteOnly):
QtWidgets.QMessageBox.warning(
self, self.tr("Spreadsheet"),
self.tr("Cannot write file {0}:\n{1}.").format(
file.fileName(), file.errorString()))
return False
out = QtCore.QDataStream(file)
out.setVersion(QtCore.QDataStream.Qt_4_1)
out << int(self.MagicNumber)
QtGui.QGuiApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
for row in range(0, self.RowCount):
for column in range(0, self.ColumnCount):
str = self.formula(row, column)
if str != "":
out << int(row)
out << int(column)
out << str
QtGui.QGuiApplication.restoreOverrideCursor()
return True
def readFile(self, fileName):
file = QtCore.QFile(fileName)
if not file.open(QtCore.QIODevice.ReadOnly):
QtWidgets.QMessageBox.warning(
self, self.tr("Spreadsheet"),
self.tr("Cannot read file %1:\n%2.").arg(
file.fileName(), file.errorString()))
return False
inp = QtCore.QDataStream(file)
inp.setVersion(QtCore.QDataStream.Qt_4_1)
magic = inp.readInt32()
if magic != self.MagicNumber:
QtWidgets.QMessageBox.warning(
self, self.tr("Spreadsheet"),
self.tr("The file is not a Spreadsheet file."))
return False
self.clear()
row = 0
column = 0
str = ""
QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
while not inp.atEnd():
# inp >> row >> column >> str
inp >> row
inp >> column
inp >> str
self.setFormula(row, column, str)
QtWidgets.QApplication.restoreOverrideCursor()
return True
def readFortune(self):
instr = QtCore.QDataStream(self.tcpSocket)
instr.setVersion(QtCore.QDataStream.Qt_4_0)
if self.blockSize == 0:
if self.tcpSocket.bytesAvailable() < 2:
return
self.blockSize = instr.readUInt16()
if self.tcpSocket.bytesAvailable() < self.blockSize:
return
nextFortune = instr.readString()
try:
# Python v3.
nextFortune = str(nextFortune, encoding='ascii')
except TypeError:
# Python v2.
pass
if nextFortune == self.currentFortune:
QtCore.QTimer.singleShot(0, self.requestNewFortune)
return
self.currentFortune = nextFortune
self.statusLabel.setText(self.currentFortune)
self.getFortuneButton.setEnabled(True)
def mousePressEvent(self, event):
child = self.childAt(event.pos())
if not child:
return
pixmap = QtGui.QPixmap(child.pixmap())
itemData = QtCore.QByteArray()
dataStream = QtCore.QDataStream(itemData, QtCore.QIODevice.WriteOnly)
dataStream << pixmap << QtCore.QPoint(event.pos() - child.pos())
mimeData = QtCore.QMimeData()
mimeData.setData('application/x-dnditemdata', itemData)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(pixmap)
drag.setHotSpot(event.pos() - child.pos())
tempPixmap = QtGui.QPixmap(pixmap)
painter = QtGui.QPainter()
painter.begin(tempPixmap)
painter.fillRect(pixmap.rect(), QtGui.QColor(127, 127, 127, 127))
painter.end()
child.setPixmap(tempPixmap)
if drag.exec_(QtCore.Qt.CopyAction | QtCore.Qt.MoveAction,
QtCore.Qt.CopyAction) == QtCore.Qt.MoveAction:
child.close()
else:
child.show()
child.setPixmap(pixmap)
def mouseMoveEvent(self, item):
"""Drag event"""
shader = self.shader
itemData = QtCore.QByteArray()
dataStream = QtCore.QDataStream(itemData, QtCore.QIODevice.WriteOnly)
dataStream << QtCore.QByteArray(str(shader))
mimeData = QtCore.QMimeData()
icon = QtGui.QIcon()
if cmds.nodeType(shader) == 'displacementShader':
mimeData.setData("application/x-displacement", itemData)
icon.addFile(os.path.join(d, "../../../icons/sgblue.xpm"),
QtCore.QSize(25, 25))
else:
mimeData.setData("application/x-shader", itemData)
icon.addFile(os.path.join(d, "../../../icons/sg.xpm"),
QtCore.QSize(25, 25))
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(icon.pixmap(50, 50))
drag.setHotSpot(QtCore.QPoint(0, 0))
drag.start(QtCore.Qt.MoveAction)
def __init__(self,
host: str,
port: int,
parent: Optional[QtCore.QObject] = None):
"""Initialise a new instance of the class."""
super().__init__(parent)
self.host: str = host
self.port: int = port
self.__accounts: Dict[int, CompetitorAccount] = dict()
self.__now: float = 0.0
self.__order_books: List[OrderBook] = list(
OrderBook(i, 0.0, 0.0) for i in Instrument)
self.__orders: Dict[int, Dict[int, Order]] = {0: dict()}
self.__stop_later: bool = False
self.__teams: Dict[int, str] = {0: ""}
self.__ask_prices: List[int] = [0] * TOP_LEVEL_COUNT
self.__ask_volumes: List[int] = [0] * TOP_LEVEL_COUNT
self.__bid_prices: List[int] = [0] * TOP_LEVEL_COUNT
self.__bid_volumes: List[int] = [0] * TOP_LEVEL_COUNT
self.__socket = QtNetwork.QTcpSocket(self)
self.__socket.connected.connect(self.on_connected)
self.__socket.disconnected.connect(self.on_disconnected)
self.__socket.errorOccurred.connect(self.on_error_occurred)
self.__socket.readyRead.connect(self.on_data_received)
self.__stream = QtCore.QDataStream(self.__socket)
def mimeDataAdd(mimeData, mimeFormat, objects):
"""Sets mime data."""
data = QtCore.QByteArray()
stream = QtCore.QDataStream(data, QtCore.QIODevice.WriteOnly)
text = ":".join(objects)
stream.writeQString(text)
mimeData.setData(mimeFormat, data)
def dropEvent(self, event):
if event.mimeData().hasFormat(
'image/x-puzzle-piece') and self.findPiece(
self.targetSquare(event.pos())) == -1:
pieceData = event.mimeData().data('image/x-puzzle-piece')
stream = QtCore.QDataStream(pieceData, QtCore.QIODevice.ReadOnly)
square = self.targetSquare(event.pos())
pixmap = QPixmap()
location = QtCore.QPoint()
stream >> pixmap >> location
self.pieceLocations.append(location)
self.piecePixmaps.append(pixmap)
self.pieceRects.append(square)
self.hightlightedRect = QtCore.QRect()
self.update(square)
event.setDropAction(QtCore.Qt.MoveAction)
event.accept()
if location == QtCore.QPoint(square.x() / 80, square.y() / 80):
self.inPlace += 1
if self.inPlace == 25:
self.puzzleCompleted.emit()
else:
self.highlightedRect = QtCore.QRect()
event.ignore()
def dropEvent(event, format = "application/x-job-names"):
if event.mimeData().hasFormat(format):
item = event.mimeData().data(format)
stream = QtCore.QDataStream(item, QtCore.QIODevice.ReadOnly)
names = stream.readQString()
event.accept()
return [name for name in str(names).split(":") if name]
def load_project(project_path):
"""Loads project from p00p file"""
file = QtCore.QFile(project_path)
if not file.open(QtCore.QIODevice.ReadOnly):
raise EnvironmentError(file.errorString())
else:
in_ = QtCore.QDataStream(file)
# Read and check the header
magic = in_.readInt32()
if magic != MAGIC_NUMBER:
raise EnvironmentError("Bad file format")
# Read the version
version = in_.readInt32()
if version > FORMAT_VERSION:
raise EnvironmentError("File too new for this version.")
in_.setVersion(QtCore.QDataStream.Qt_5_14)
# Read the data
data_size = in_.readInt32()
data = in_.readRawData(data_size)
file.close()
return Project.from_JSON_serializable(pickle.loads(bytes(data)),
project_path)
def dropMimeData(self, data, action, row, column, parent):
if not data.hasFormat('image/x-puzzle-piece'):
return False
if action == QtCore.Qt.IgnoreAction:
return True
if column > 0:
return False
if not parent.isValid():
if row < 0:
endRow = len(self.pixmaps)
else:
endRow = min(row, len(self.pixmaps))
else:
endRow = parent.row()
encodedData = data.data('image/x-puzzle-piece')
stream = QtCore.QDataStream(encodedData, QtCore.QIODevice.ReadOnly)
while not stream.atEnd():
pixmap = QPixmap()
location = QtCore.QPoint()
stream >> pixmap >> location
self.beginInsertRows(QtCore.QModelIndex(), endRow, endRow)
self.pixmaps.insert(endRow, pixmap)
self.locations.insert(endRow, location)
self.endInsertRows()
endRow += 1
return True
def serialize(self) -> QtCore.QByteArray:
_bytearray = QtCore.QByteArray()
datastream = QtCore.QDataStream(_bytearray, QtCore.QIODevice.WriteOnly)
datastream.writeUInt8(self.contentType)
datastream.writeString(self.payload)
return _bytearray
def write(self, data):
block = QtCore.QByteArray()
out = QtCore.QDataStream(block, QtCore.QIODevice.ReadWrite)
out.setVersion(QtCore.QDataStream.Qt_4_2)
out.writeUInt32(2 * len(data) + 4)
out.writeQString(data)
if self.socket.state() == QtNetwork.QAbstractSocket.ConnectedState:
self.socket.write(block)
def deserialize(_bytearray: QtCore.QByteArray) -> "Packet":
packet = Packet()
datastream = QtCore.QDataStream(_bytearray)
packet.contentType = datastream.readUInt8()
packet.payload = datastream.readString()
return packet
def copy(self):
items = selectedItems(self.p_scene, self.w_parent)
if items is None:
return
self.w_parent.copiedItems.clear()
self.w_parent.pasteOffset = 5
stream = QtCore.QDataStream(self.w_parent.copiedItems,
QtCore.QIODevice.WriteOnly)
writeItemToBuffer(stream, items)
def mimeData(nodeNames):
mimeData = QtCore.QMimeData()
encodedData = QtCore.QByteArray()
stream = QtCore.QDataStream(encodedData, QtCore.QIODevice.WriteOnly)
for name in nodeNames:
stream.writeString(name)
mimeData.setData(renderSetupProxy.RENDER_SETUP_MIME_TYPE, encodedData)
return mimeData
def paste(self):
if self.w_parent.copiedItems.isEmpty():
return
stream = QtCore.QDataStream(self.w_parent.copiedItems,
QtCore.QIODevice.ReadOnly)
readItemsFromBuffer(stream,
self.p_scene,
self.w_parent,
self.w_parent.pasteOffset,
snap=self.a_snap)
self.w_parent.pasteOffset += 5
def save(self):
"""Saves the project at project path as p00p file"""
file = QtCore.QFile(self.path)
if not file.open(QtCore.QIODevice.WriteOnly):
raise EnvironmentError(file.errorString())
else:
data = QtCore.QByteArray(
pickle.dumps(self.to_JSON_serializable(), protocol=4))
out = QtCore.QDataStream(file)
out.writeInt32(MAGIC_NUMBER)
out.writeInt32(FORMAT_VERSION)
out.setVersion(QtCore.QDataStream.Qt_5_14)
out << data
file.close()
def read(self):
ins = QtCore.QDataStream(self.socket)
ins.setVersion(QtCore.QDataStream.Qt_4_2)
while not ins.atEnd():
if self.block_size == 0:
if self.socket.bytesAvailable() < 4:
return
self.block_size = ins.readUInt32()
if self.socket.bytesAvailable() < self.block_size:
return
data = ins.readQString()
self.block_size = 0
self.message_stream.on_next(data)
def dropEvent(self, event):
if event.mimeData().hasFormat('image/x-puzzle-piece'):
pieceData = event.mimeData().data('image/x-puzzle-piece')
dataStream = QtCore.QDataStream(pieceData, QtCore.QIODevice.ReadOnly)
pixmap = QtGui.QPixmap()
location = QtCore.QPoint()
dataStream >> pixmap >> location
self.addPiece(pixmap, location)
event.setDropAction(QtCore.Qt.MoveAction)
event.accept()
else:
event.ignore()
def mimeData(self, indexes):
mimeData = QtCore.QMimeData()
encodedData = QtCore.QByteArray()
stream = QtCore.QDataStream(encodedData, QtCore.QIODevice.WriteOnly)
for index in indexes:
if index.isValid():
pixmap = QPixmap(self.data(index, QtCore.Qt.UserRole))
location = self.data(index, QtCore.Qt.UserRole + 1)
stream << pixmap << location
mimeData.setData('image/x-puzzle-piece', encodedData)
return mimeData
def sendFortune(self):
block = QtCore.QByteArray()
out = QtCore.QDataStream(block, QtCore.QIODevice.WriteOnly)
out.setVersion(QtCore.QDataStream.Qt_4_0)
out.writeUInt16(0)
fortune = self.fortunes[random.randint(0, len(self.fortunes) - 1)]
out.writeString(fortune)
out.device().seek(0)
out.writeUInt16(block.size() - 2)
clientConnection = self.tcpServer.nextPendingConnection()
clientConnection.disconnected.connect(clientConnection.deleteLater)
clientConnection.write(block)
clientConnection.disconnectFromHost()
def dropEvent(self, event):
if event.mimeData().hasFormat("image/x-workflow-step"):
piece_data = event.mimeData().data("image/x-workflow-step")
stream = QtCore.QDataStream(piece_data, QtCore.QIODevice.ReadOnly)
hot_spot = QtCore.QPoint()
_name_len = stream.readUInt32()
buf = QtCore.QByteArray()
stream >> buf
name = buf.data().decode()
stream >> hot_spot
position = self.mapToScene(event.pos()) - hot_spot
scene = self.scene()
# Create a step with the given name.
step = workflowStepFactory(name, self._location)
self.set_default_id(step)
step.setMainWindow(self._main_window)
step.setLocation(self._location)
step.registerConfiguredObserver(scene.stepConfigured)
step.registerDoneExecution(scene.doneExecution)
step.registerOnExecuteEntry(scene.setCurrentWidget)
step.registerIdentifierOccursCount(scene.identifierOccursCount)
# Trigger a validation.
step.deserialize(step.serialize())
# Prepare meta step for the graphics scene.
meta_step = MetaStep(step)
node = Node(meta_step)
node.showStepName(self._showStepNames)
self._undoStack.beginMacro('Add node')
self._undoStack.push(CommandAdd(scene, node))
# Set the position after it has been added to the scene.
self._undoStack.push(CommandMove(node, position, scene.ensureItemInScene(node, position)))
scene.clearSelection()
node.setSelected(True)
self._undoStack.endMacro()
self.setFocus()
event.accept()
else:
event.ignore()
def run(self):
tcpSocket = QtNetwork.QTcpSocket()
if not tcpSocket.setSocketDescriptor(self.socketDescriptor):
self.error.emit(tcpSocket.error())
return
block = QtCore.QByteArray()
outstr = QtCore.QDataStream(block, QtCore.QIODevice.WriteOnly)
outstr.setVersion(QtCore.QDataStream.Qt_4_0)
outstr.writeUInt16(0)
outstr.writeString(self.text)
outstr.device().seek(0)
outstr.writeUInt16(block.count() - 2)
tcpSocket.write(block)
tcpSocket.disconnectFromHost()
tcpSocket.waitForDisconnected()
def run(self):
self.mutex.lock()
serverName = self.hostName
serverPort = self.port
self.mutex.unlock()
while not self.quit:
Timeout = 5 * 1000
socket = QtNetwork.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 = QtCore.QDataStream(socket)
instr.setVersion(QtCore.QDataStream.Qt_4_0)
blockSize = instr.readUInt16()
while socket.bytesAvailable() < blockSize:
if not socket.waitForReadyRead(Timeout):
self.error.emit(socket.error(), socket.errorString())
return
self.mutex.lock()
fortune = instr.readString()
try:
# Python v3.
fortune = str(fortune, encoding='ascii')
except TypeError:
# Python v2.
pass
self.newFortune.emit(fortune)
self.cond.wait(self.mutex)
serverName = self.hostName
serverPort = self.port
self.mutex.unlock()
def startDrag(self, supportedActions):
item = self.currentItem()
itemData = QtCore.QByteArray()
dataStream = QtCore.QDataStream(itemData, QtCore.QIODevice.WriteOnly)
pixmap = QtGui.QPixmap(item.data(QtCore.Qt.UserRole))
location = item.data(QtCore.Qt.UserRole+1)
dataStream << pixmap << location
mimeData = QtCore.QMimeData()
mimeData.setData('image/x-puzzle-piece', itemData)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(QtCore.QPoint(pixmap.width()/2, pixmap.height()/2))
drag.setPixmap(pixmap)
if drag.exec_(QtCore.Qt.MoveAction) == QtCore.Qt.MoveAction:
self.takeItem(self.row(item))
