def setup(self, node):
# Create message and add delay time for accurate dave time estimates
self.message = tcpMessage.TCPMessage(message_type="Pause")
# Define pause behaviors
self.should_pause = True
self.should_pause_default = True
def moveStageMessage(stagex, stagey, is_other=False):
return tcpMessage.TCPMessage(message_type="Move Stage",
message_data={
"stage_x": stagex,
"stage_y": stagey,
"is_other": is_other
})
def __init__(self, tcp_client, command):
DaveAction.__init__(self, tcp_client)
self.message = tcpMessage.TCPMessage(message_type="Move Stage",
message_data={
"stage_x": command.stage_x,
"stage_y": command.stage_y
})
def __init__(self, tcp_client, protocol_xml):
DaveAction.__init__(self, tcp_client)
self.protocol_name = protocol_xml.protocol_name
self.protocol_is_running = False
self.message = tcpMessage.TCPMessage(
message_type="Kilroy Protocol",
message_data={"name": self.protocol_name})
def setup(self, node):
self.directory = node.find("directory").text
self.message = tcpMessage.TCPMessage(
message_type="Set Directory",
message_data={"directory": self.directory})
# Require validation
self.id = self.message.getType() + " "
self.id += self.directory
def __init__(self, should_pause):
# Initialize parent class with no tcp_client
DaveAction.__init__(self, None)
# Create message and add delay time for accurate dave time estimates
self.message = tcpMessage.TCPMessage(message_type="Pause")
# Define pause behaviors
self.should_pause = should_pause
def __init__(self, tcp_client, progression):
DaveAction.__init__(self, tcp_client)
message_data = {"type": progression.type}
if hasattr(progression, "filename"):
message_data["filename"] = progression.filename
if progression.channels:
message_data["channels"] = progression.channels
self.message = tcpMessage.TCPMessage(message_type="Set Progression",
message_data=message_data)
def setup(self, node):
self.protocol_name = node.text
self.protocol_is_running = False
self.message = tcpMessage.TCPMessage(
message_type="Kilroy Protocol",
message_data={"name": self.protocol_name})
# Require validation
self.id = self.message.getType() + " "
self.id = self.protocol_name
def setup(self, node):
# Prepare delay timer
self.delay_timer = QtCore.QTimer(self)
self.delay_timer.setSingleShot(True)
self.delay_timer.timeout.connect(self.handleTimerComplete)
self.delay = int(node.find("delay").text)
# Create message and add delay time for accurate dave time estimates
self.message = tcpMessage.TCPMessage(
message_type="Delay", message_data={"delay": self.delay})
self.message.addResponse("duration", self.delay)
def setup(self, node):
self.stage_x = float(node.find("stage_x").text)
self.stage_y = float(node.find("stage_y").text)
self.message = tcpMessage.TCPMessage(message_type="Move Stage",
message_data={
"stage_x": self.stage_x,
"stage_y": self.stage_y
})
# Create id to indicate required validation
self.id = self.message.getType() + " "
self.id += "stage_x: " + str(self.stage_x) + " "
self.id += "stage_y: " + str(self.stage_y)
def setup(self, node):
p_node = node.find("parameters")
if (p_node.attrib["type"] == "int"):
self.parameters = int(node.find("parameters").text)
else:
self.parameters = node.find("parameters").text
self.message = tcpMessage.TCPMessage(
message_type="Set Parameters",
message_data={"parameters": self.parameters})
# Require validation
self.id = self.message.getType() + " "
self.id += str(self.parameters)
def setup(self, node):
# Look for message data
if node.find("subject") is not None:
self.email_subject = node.find("subject").text
if node.find("body") is not None:
self.email_body = node.find("body").text
# Create message data
message_data = {"subject": self.email_subject, "body": self.email_body}
self.message = tcpMessage.TCPMessage(message_type="Dave Email",
message_data=message_data)
def __init__(self, delay):
# Initialize parent class with no tcp_client
DaveAction.__init__(self, None)
# Prepare delay timer
self.delay_timer = QtCore.QTimer(self)
self.delay_timer.setSingleShot(True)
self.delay_timer.timeout.connect(self.handleTimerComplete)
self.delay = delay
# Create message and add delay time for accurate dave time estimates
self.message = tcpMessage.TCPMessage(
message_type="Delay", message_data={"delay", self.delay})
self.message.addResponse("duration", self.delay)
def setup(self, node):
# Determine the number of focus checks
if node.find("num_focus_checks") is not None:
self.num_focus_checks = int(node.find("num_focus_checks").text)
# Add focus_scan flag if provided
if node.find("focus_scan") is not None:
self.focus_scan = True
message_data = {
"num_focus_checks": self.num_focus_checks,
"focus_scan": self.focus_scan
}
self.message = tcpMessage.TCPMessage(message_type="Check Focus Lock",
message_data=message_data)
def __init__(self, tcp_client, command):
DaveAction.__init__(self, tcp_client)
message_data = {
"name": command.name,
"length": command.length,
"min_spots": command.min_spots
}
if hasattr(command, "parameters"):
message_data["parameters"] = command.parameters
else:
message_data["parameters"] = None
if hasattr(command, "directory"):
message_data["directory"] = command.directory
if hasattr(command, "overwrite"):
message_data["overwrite"] = command.overwrite
self.min_spots = command.min_spots
self.message = tcpMessage.TCPMessage(message_type="Take Movie",
message_data=message_data)
def setup(self, node):
self.type = node.find("type").text
message_data = {"type": self.type}
# File progression.
if node.find("filename") is not None:
message_data["filename"] = node.find("filename").text
# Math progression.
elif node.find("channel") is not None:
channels = []
for ch_node in [x for x in node if (x.tag == "channel")]:
channel = int(ch_node.text)
start = float(ch_node.attrib["start"])
if "frames" in ch_node.attrib:
frames = int(ch_node.attrib["frames"])
else:
frames = 100
if "inc" in ch_node.attrib:
inc = float(ch_node.attrib["inc"])
else:
inc = 0.0
channels.append([channel, start, frames, inc])
message_data["channels"] = channels
self.message = tcpMessage.TCPMessage(message_type="Set Progression",
message_data=message_data)
# Require validation only for provided filenames
if node.find("filename") is not None:
self.id = self.message.getType() + " "
self.id += node.find("filename").text
def setup(self, node):
self.name = node.find("name").text
self.length = int(node.find("length").text)
self.min_spots = 0
if node.find("min_spots") is not None:
self.min_spots = int(node.find("min_spots").text)
message_data = {
"name": self.name,
"length": self.length,
"min_spots": self.min_spots,
"parameters": None
}
if node.find("parameters") is not None:
message_data["parameters"] = node.find("parameters").text
if node.find("directory") is not None:
message_data["directory"] = node.find("directory").text
if node.find("overwrite") is not None:
message_data["overwrite"] = True # Default is to overwrite
boolean_text = node.find("overwrite").text
if (boolean_text.lower() == "false"):
message_data["overwrite"] = False
self.message = tcpMessage.TCPMessage(message_type="Take Movie",
message_data=message_data)
# Require validation
self.id = self.message.getType() + " "
self.id = str(self.length) + " "
if message_data["parameters"] is not None:
self.id = str(message_data["parameters"])
def getPositionMessage():
return tcpMessage.TCPMessage(message_type="Get Stage Position")
def movieMessage(filename):
return tcpMessage.TCPMessage(message_type="Take Movie",
message_data={
"name": filename,
"length": 1
})
def setup(self, node):
self.lock_target = float(node.find("lock_target").text)
self.message = tcpMessage.TCPMessage(
message_type="Set Lock Target",
message_data={"lock_target": self.lock_target})
def __init__(self, tcp_client, min_sum):
DaveAction.__init__(self, tcp_client)
self.min_sum = min_sum
self.message = tcpMessage.TCPMessage(message_type="Find Sum",
message_data={"min_sum": min_sum})
def setup(self, node):
self.message = tcpMessage.TCPMessage(message_type="Recenter Piezo")
def __init__(self, tcp_client):
DaveAction.__init__(self, tcp_client)
self.message = tcpMessage.TCPMessage(message_type="Recenter Piezo")
def __init__(self, tcp_client, directory):
DaveAction.__init__(self, tcp_client)
self.message = tcpMessage.TCPMessage(
message_type="Set Directory",
message_data={"directory": directory})
def setup(self, node):
self.min_sum = float(node.find("min_sum").text)
self.message = tcpMessage.TCPMessage(
message_type="Find Sum", message_data={"min_sum": self.min_sum})
def __init__(self, tcp_client, lock_target):
DaveAction.__init__(self, tcp_client)
self.message = tcpMessage.TCPMessage(
message_type="Set Lock Target",
message_data={"lock_target": lock_target})
def setup(self, node):
self.message = tcpMessage.TCPMessage(message_type="Clear Warnings",
message_data={})
def __init__(self, tcp_client, command):
DaveAction.__init__(self, tcp_client)
self.message = tcpMessage.TCPMessage(
message_type="Set Parameters",
message_data={"parameters": command.parameters})
def abort(self):
stop_message = tcpMessage.TCPMessage(message_type="Abort Movie")
self.tcp_client.sendMessage(stop_message)
def mosaicSettingsMessage():
return tcpMessage.TCPMessage(message_type="Get Mosaic Settings")
