beremiz: comparison PLCControler.py

equal deleted inserted replaced

-:c74815729afd
+:691083b5682a
 #-------------------------------------------------------------------------------
 _Point = namedtuple("Point", ["x", "y"])
-_BlockInstanceInfos = namedtuple("BlockInstanceInfos",
+_BlockInstanceInfos = namedtuple(
+"BlockInstanceInfos",
 ["type", "id", "x", "y", "width", "height", "specific_values", "inputs", "outputs"])
 _BlockSpecificValues = (
 namedtuple("BlockSpecificValues",
 ["name", "execution_order"]),
 "actionBlock": (
 namedtuple("ActionBlockSpecificValues", ["actions"]),
 [lambda x: x]),
 }
-_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",
+_InstanceConnectionInfos = namedtuple(
+"InstanceConnectionInfos",
 ["name", "negated", "edge", "position", "links"])
-_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",
+_ConnectionLinkInfos = namedtuple(
+"ConnectionLinkInfos",
 ["refLocalId", "formalParameter", "points"])
 class _ActionInfos(object):
 __slots__ = ["qualifier", "type", "value", "duration", "indicator"]
 project = self.GetProject(debug)
 if project is not None:
 infos = {"name": project.getname(), "type": ITEM_PROJECT}
 datatypes = {"name": DATA_TYPES, "type": ITEM_DATATYPES, "values": []}
 for datatype in project.getdataTypes():
-datatypes["values"].append({"name": datatype.getname(), "type": ITEM_DATATYPE,
+datatypes["values"].append({
-"tagname": self.ComputeDataTypeName(datatype.getname()), "values": []})
+"name": datatype.getname(),
+"type": ITEM_DATATYPE,
+"tagname": self.ComputeDataTypeName(datatype.getname()),
+"values": []})
 pou_types = {
 "function": {
 "name":   FUNCTIONS,
 "type":   ITEM_FUNCTION,
 "values": []
 "tagname": self.ComputePouName(pou.getname())}
 pou_values = []
 if pou.getbodyType() == "SFC":
 transitions = []
 for transition in pou.gettransitionList():
-transitions.append({"name": transition.getname(), "type": ITEM_TRANSITION,
+transitions.append({
+"name": transition.getname(),
+"type": ITEM_TRANSITION,
 "tagname": self.ComputePouTransitionName(pou.getname(), transition.getname()),
 "values": []})
 pou_values.append({"name": TRANSITIONS, "type": ITEM_TRANSITIONS, "values": transitions})
 actions = []
 for action in pou.getactionList():
-actions.append({"name": action.getname(), "type": ITEM_ACTION,
+actions.append({
+"name": action.getname(),
+"type": ITEM_ACTION,
 "tagname": self.ComputePouActionName(pou.getname(), action.getname()),
 "values": []})
 pou_values.append({"name": ACTIONS, "type": ITEM_ACTIONS, "values": actions})
 if pou_type in pou_types:
 pou_infos["values"] = pou_values
 pou_types[pou_type]["values"].append(pou_infos)
 configurations = {"name": CONFIGURATIONS, "type": ITEM_CONFIGURATIONS, "values": []}
 for config in project.getconfigurations():
 config_name = config.getname()
-config_infos = {"name": config_name, "type": ITEM_CONFIGURATION,
+config_infos = {
+"name": config_name,
+"type": ITEM_CONFIGURATION,
 "tagname": self.ComputeConfigurationName(config.getname()),
 "values": []}
 resources = {"name": RESOURCES, "type": ITEM_RESOURCES, "values": []}
 for resource in config.getresource():
 resource_name = resource.getname()
-resource_infos = {"name": resource_name, "type": ITEM_RESOURCE,
+resource_infos = {
+"name": resource_name,
+"type": ITEM_RESOURCE,
 "tagname": self.ComputeConfigurationResourceName(config.getname(), resource.getname()),
 "values": []}
 resources["values"].append(resource_infos)
 config_infos["values"] = [resources]
 configurations["values"].append(config_infos)
 os.path.join(ScriptDirectory, "plcopen", "instances_path.xslt"),
 parser),
 extensions={
 ("instances_ns", "AddInstance"): factory.AddInstance})
-instances_path_xslt_tree(root,
+instances_path_xslt_tree(
-instance_type=etree.XSLT.strparam(name))
+root, instance_type=etree.XSLT.strparam(name))
 return instances
 def SearchPouInstances(self, tagname, debug=False):
 project = self.GetProject(debug)
 "ResourceTagName",
 "PouTagName",
 "ActionTagName",
 "TransitionTagName"]})
-instance_tagname_xslt_tree(project,
+instance_tagname_xslt_tree(
-instance_path=etree.XSLT.strparam(instance_path))
+project, instance_path=etree.XSLT.strparam(instance_path))
 return factory.GetTagName()
 def GetInstanceInfos(self, instance_path, debug=False):
 tagname = self.GetPouInstanceTagName(instance_path)
 variables_infos_xslt_tree = etree.XSLT(
 etree.parse(
 os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"),
 parser),
 extensions={("var_infos_ns", name): getattr(factory, name)
 for name in ["SetType", "AddDimension", "AddTree",
 "AddVarToTree", "AddVariable"]})
-variables_infos_xslt_tree(object_with_vars,
+variables_infos_xslt_tree(
-tree=etree.XSLT.strparam(str(tree)))
+object_with_vars, tree=etree.XSLT.strparam(str(tree)))
 return variables
 # Add a global var to configuration to configuration
 def AddConfigurationGlobalVar(self, config_name, var_type, var_name,
 if project is not None:
 for configuration in self.Project.getconfigurations():
 if config_name is None or config_name == configuration.getname():
 variables.extend(
 [var.getname() for var in reduce(
-lambda x, y: x + y, [varlist.getvariable()
+lambda x, y: x + y, [
+varlist.getvariable()
 for varlist in configuration.globalVars],
 [])])
 return variables
 # Replace the resource globalvars by those given
 return self.GetVariableDictionary(resource, debug)
 return []
 # Return resource variable names
-def GetConfigurationResourceVariableNames(self,
+def GetConfigurationResourceVariableNames(
-config_name=None, resource_name=None, debug=False):
+self, config_name=None, resource_name=None, debug=False):
 variables = []
 project = self.GetProject(debug)
 if project is not None:
 for configuration in self.Project.getconfigurations():
 if config_name is None or config_name == configuration.getname():
 for resource in configuration.getresource():
 if resource_name is None or resource.getname() == resource_name:
 variables.extend(
 [var.getname() for var in reduce(
-lambda x, y: x + y, [varlist.getvariable()
+lambda x, y: x + y, [
+varlist.getvariable()
 for varlist in resource.globalVars],
 [])])
 return variables
 # Return the interface for the given pou
 os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"),
 parser),
 extensions={("var_infos_ns", name): getattr(factory, name)
 for name in ["SetType", "AddDimension",
 "AddTree", "AddVarToTree"]})
-return_type_infos_xslt_tree(return_type,
+return_type_infos_xslt_tree(
-tree=etree.XSLT.strparam(str(tree)))
+return_type, tree=etree.XSLT.strparam(str(tree)))
 if tree:
 return [factory.GetType(), factory.GetTree()]
 return factory.GetType()
 if tree:
 blocktype_infos = blocktype.getblockInfos()
 if inputs in [None, "undefined"]:
 return blocktype_infos
 if inputs == tuple([var_type
 for name, var_type, modifier in blocktype_infos["inputs"]]):
 return blocktype_infos
 return None
 # Return Block types checking for recursion
 blocktypes = [
 {"name": category["name"],
 "list": [block for block in category["list"]
 if block["type"] in filter]}
 for category in self.TotalTypes]
-blocktypes.append({"name": USER_DEFINED_POUS,
+blocktypes.append({
+"name": USER_DEFINED_POUS,
 "list": [pou.getblockInfos()
 for pou in project.getpous(name, filter)
 if (name is None or
-len(self.GetInstanceList(pou, name, debug)) == 0)]})
+len(self.GetInstanceList(pou, name, debug)) == 0)]
+})
 return blocktypes
 return self.TotalTypes
 # Return Function Block types checking for recursion
 def GetFunctionBlockTypes(self, tagname="", debug=False):
 for blocks in self.TotalTypesDict.itervalues():
 for sectioname, block in blocks:
 if block["type"] == "functionBlock":
 blocktypes.append(block["name"])
 if project is not None:
-blocktypes.extend([pou.getname()
+blocktypes.extend([
+pou.getname()
 for pou in project.getpous(name, ["functionBlock"])
 if (name is None or
 len(self.GetInstanceList(pou, name, debug)) == 0)])
 return blocktypes
 infos["min"] = basetype_content.range.getlower()
 infos["max"] = basetype_content.range.getupper()
 base_type = basetype_content.baseType.getcontent()
 base_type_type = base_type.getLocalTag()
 infos["base_type"] = (base_type.getname()
 if base_type_type == "derived"
 else base_type_type)
 elif basetype_content_type == "enum":
 infos["type"] = "Enumerated"
 infos["values"] = []
 for value in basetype_content.xpath("ppx:values/ppx:value", namespaces=PLCOpenParser.NSMAP):
 infos["values"].append(value.getname())
 for dimension in basetype_content.getdimension():
 infos["dimensions"].append((dimension.getlower(), dimension.getupper()))
 base_type = basetype_content.baseType.getcontent()
 base_type_type = base_type.getLocalTag()
 infos["base_type"] = (base_type.getname()
 if base_type_type == "derived"
 else base_type_type.upper())
 elif basetype_content_type == "struct":
 infos["type"] = "Structure"
 infos["elements"] = []
 for element in basetype_content.getvariable():
 element_infos = {}
 for dimension in element_type.getdimension():
 dimensions.append((dimension.getlower(), dimension.getupper()))
 base_type = element_type.baseType.getcontent()
 base_type_type = base_type.getLocalTag()
 element_infos["Type"] = ("array",
 base_type.getname()
 if base_type_type == "derived"
-else base_type_type.upper(), dimensions)
+else base_type_type.upper(),
+dimensions)
 elif element_type_type == "derived":
 element_infos["Type"] = element_type.getname()
 else:
 element_infos["Type"] = element_type_type.upper()
 if element.initialValue is not None:
 element_infos["Initial Value"] = ""
 infos["elements"].append(element_infos)
 else:
 infos["type"] = "Directly"
 infos["base_type"] = (basetype_content.getname()
 if basetype_content_type == "derived"
 else basetype_content_type.upper())
 if datatype.initialValue is not None:
 infos["initial"] = datatype.initialValue.getvalue()
 else:
 infos["initial"] = ""
 words = tagname.split("::")
 if words[0] in ["P", "T", "A"]:
 element = self.GetEditedElement(tagname, debug)
 if element is not None and element.getbodyType() not in ["ST", "IL"]:
 for instance in element.getinstances():
-if isinstance(instance,
+if isinstance(
-(PLCOpenParser.GetElementClass("step", "sfcObjects"),
+instance,
-PLCOpenParser.GetElementClass("connector", "commonObjects"),
+(PLCOpenParser.GetElementClass("step",         "sfcObjects"),
-PLCOpenParser.GetElementClass("continuation", "commonObjects"))):
+PLCOpenParser.GetElementClass("connector",    "commonObjects"),
+PLCOpenParser.GetElementClass("continuation", "commonObjects"))):
 names[instance.getname().upper()] = True
 else:
 project = self.GetProject(debug)
 if project is not None:
 for datatype in project.getdataTypes():

changeset 1768	691083b5682a
parent 1767	c74815729afd
child 1773	38fde37c3766