beremiz: comparison PLCControler.py

equal deleted inserted replaced

-:c3c3d1318130
+:69dfdb26f600
 class UndoBuffer:
 """
 Class implementing a buffer of changes made on the current editing model
 """
-def __init__(self, currentstate, issaved = False):
+def __init__(self, currentstate, issaved=False):
 """
 Constructor initialising buffer
 """
 self.Buffer = []
 self.CurrentIndex = -1
 self.ProgramFilePath = ""
 def GetQualifierTypes(self):
 return QualifierList
-def GetProject(self, debug = False):
+def GetProject(self, debug=False):
 if debug and self.CurrentCompiledProject is not None:
 return self.CurrentCompiledProject
 else:
 return self.Project
 self.NextCompiledProject = self.Copy(self.Project)
 self.CurrentCompiledProject = None
 self.Buffering = False
 # Return project data type names
-def GetProjectDataTypeNames(self, debug = False):
+def GetProjectDataTypeNames(self, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 return [datatype.getname() for datatype in project.getdataTypes()]
 return []
 # Return project pou names
-def GetProjectPouNames(self, debug = False):
+def GetProjectPouNames(self, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 return [pou.getname() for pou in project.getpous()]
 return []
 # Return project pou names
-def GetProjectConfigNames(self, debug = False):
+def GetProjectConfigNames(self, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 return [config.getname() for config in project.getconfigurations()]
 return []
 # Return project pou variable names
-def GetProjectPouVariableNames(self, pou_name = None, debug = False):
+def GetProjectPouVariableNames(self, pou_name=None, debug=False):
 variables = []
 project = self.GetProject(debug)
 if project is not None:
 for pou in project.getpous():
 if pou_name is None or pou_name == pou.getname():
 self.FileName = _("Unnamed%d") % self.LastNewIndex
 else:
 self.FileName = os.path.splitext(os.path.basename(filepath))[0]
 # Change project properties
-def SetProjectProperties(self, name = None, properties = None, buffer = True):
+def SetProjectProperties(self, name=None, properties=None, buffer=True):
 if self.Project is not None:
 if name is not None:
 self.Project.setname(name)
 if properties is not None:
 self.Project.setfileHeader(properties)
 if project is not None:
 return project.getname()
 return None
 # Return project properties
-def GetProjectProperties(self, debug = False):
+def GetProjectProperties(self, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 properties = project.getfileHeader()
 properties.update(project.getcontentHeader())
 return properties
 return None
 # Return project informations
-def GetProjectInfos(self, debug = False):
+def GetProjectInfos(self, debug=False):
 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():
 infos["values"] = [datatypes, pou_types["function"], pou_types["functionBlock"],
 pou_types["program"], configurations]
 return infos
 return None
-def GetPouVariables(self, tagname, debug = False):
+def GetPouVariables(self, tagname, debug=False):
 pou_type = None
 project = self.GetProject(debug)
 if project is not None:
 factory = VariablesTreeInfosFactory()
 pou_variable_xslt_tree = etree.XSLT(
 etree.parse(
 os.path.join(ScriptDirectory, "plcopen", "pou_variables.xslt"),
 parser),
-extensions = {("pou_vars_ns", name): getattr(factory, name)
+extensions={("pou_vars_ns", name): getattr(factory, name)
 for name in ["SetRoot", "AddVariable"]})
 obj = None
 words = tagname.split("::")
 if words[0] == "P":
 pou_variable_xslt_tree(obj)
 return factory.GetRoot()
 return None
-def GetInstanceList(self, root, name, debug = False):
+def GetInstanceList(self, root, name, debug=False):
 instances = []
 project = self.GetProject(debug)
 if project is not None:
 factory = InstancesPathFactory(instances)
 instances_path_xslt_tree = etree.XSLT(
 etree.parse(
 os.path.join(ScriptDirectory, "plcopen", "instances_path.xslt"),
 parser),
-extensions = {
+extensions={
 ("instances_ns", "AddInstance"): factory.AddInstance})
 instances_path_xslt_tree(root,
 instance_type=etree.XSLT.strparam(name))
 return instances
-def SearchPouInstances(self, tagname, debug = False):
+def SearchPouInstances(self, tagname, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 words = tagname.split("::")
 if words[0] == "P":
 return self.GetInstanceList(project, words[1])
 return ["%s.%s" % (instance, words[2])
 for instance in self.SearchPouInstances(
 self.ComputePouName(words[1]), debug)]
 return []
-def GetPouInstanceTagName(self, instance_path, debug = False):
+def GetPouInstanceTagName(self, instance_path, debug=False):
 project = self.GetProject(debug)
 factory = InstanceTagName(self)
 parser = etree.XMLParser()
 parser.resolvers.add(LibraryResolver(self, debug))
 instance_tagname_xslt_tree = etree.XSLT(
 etree.parse(
 os.path.join(ScriptDirectory, "plcopen", "instance_tagname.xslt"),
 parser),
-extensions = {("instance_tagname_ns", name): getattr(factory, name)
+extensions={("instance_tagname_ns", name): getattr(factory, name)
 for name in ["ConfigTagName", "ResourceTagName",
 "PouTagName", "ActionTagName",
 "TransitionTagName"]})
 instance_tagname_xslt_tree(project,
 instance_path=etree.XSLT.strparam(instance_path))
 return factory.GetTagName()
-def GetInstanceInfos(self, instance_path, debug = False):
+def GetInstanceInfos(self, instance_path, debug=False):
 tagname = self.GetPouInstanceTagName(instance_path)
 if tagname is not None:
 infos = self.GetPouVariables(tagname, debug)
 infos.type = tagname
 return infos
 if var_infos.name == var_name:
 return var_infos
 return None
 # Return if data type given by name is used by another data type or pou
-def DataTypeIsUsed(self, name, debug = False):
+def DataTypeIsUsed(self, name, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 return len(self.GetInstanceList(project, name, debug)) > 0
 return False
 # Return if pou given by name is used by another pou
-def PouIsUsed(self, name, debug = False):
+def PouIsUsed(self, name, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 return len(self.GetInstanceList(project, name, debug)) > 0
 return False
 # Return if pou given by name is directly or undirectly used by the reference pou
-def PouIsUsedBy(self, name, reference, debug = False):
+def PouIsUsedBy(self, name, reference, debug=False):
 pou_infos = self.GetPou(reference, debug)
 if pou_infos is not None:
 return len(self.GetInstanceList(pou_infos, name, debug)) > 0
 return False
 # prevent violations of POU content restrictions:
 # function blocks cannot be pasted as functions,
 # programs cannot be pasted as functions or function blocks
 if orig_type == 'functionBlock' and pou_type == 'function' or \
 orig_type == 'program' and pou_type in ['function', 'functionBlock']:
-msg = _('''{a1} "{a2}" can't be pasted as a {a3}.''').format(a1 = orig_type, a2 = name, a3 = pou_type)
+msg = _('''{a1} "{a2}" can't be pasted as a {a3}.''').format(a1=orig_type, a2=name, a3=pou_type)
 return msg
 new_pou.setpouType(pou_type)
 self.Project.insertpou(0, new_pou)
 if resource is not None:
 resource.setname(new_name)
 self.BufferProject()
 # Return the description of the pou given by its name
-def GetPouDescription(self, name, debug = False):
+def GetPouDescription(self, name, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name and return its type
 pou = project.getpou(name)
 if pou is not None:
 return pou.getdescription()
 return ""
 # Return the description of the pou given by its name
-def SetPouDescription(self, name, description, debug = False):
+def SetPouDescription(self, name, description, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name and return its type
 pou = project.getpou(name)
 if pou is not None:
 pou.setdescription(description)
 self.BufferProject()
 # Return the type of the pou given by its name
-def GetPouType(self, name, debug = False):
+def GetPouType(self, name, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name and return its type
 pou = project.getpou(name)
 if pou is not None:
 return pou.getpouType()
 return None
 # Return pous with SFC language
-def GetSFCPous(self, debug = False):
+def GetSFCPous(self, debug=False):
 list = []
 project = self.GetProject(debug)
 if project is not None:
 for pou in project.getpous():
 if pou.getBodyType() == "SFC":
 list.append(pou.getname())
 return list
 # Return the body language of the pou given by its name
-def GetPouBodyType(self, name, debug = False):
+def GetPouBodyType(self, name, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name and return its body language
 pou = project.getpou(name)
 if pou is not None:
 return pou.getbodyType()
 return None
 # Return the actions of a pou
-def GetPouTransitions(self, pou_name, debug = False):
+def GetPouTransitions(self, pou_name, debug=False):
 transitions = []
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name and return its transitions if SFC
 pou = project.getpou(pou_name)
 for transition in pou.gettransitionList():
 transitions.append(transition.getname())
 return transitions
 # Return the body language of the transition given by its name
-def GetTransitionBodyType(self, pou_name, pou_transition, debug = False):
+def GetTransitionBodyType(self, pou_name, pou_transition, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name
 pou = project.getpou(pou_name)
 if pou is not None:
 if transition is not None:
 return transition.getbodyType()
 return None
 # Return the actions of a pou
-def GetPouActions(self, pou_name, debug = False):
+def GetPouActions(self, pou_name, debug=False):
 actions = []
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name and return its actions if SFC
 pou = project.getpou(pou_name)
 for action in pou.getactionList():
 actions.append(action.getname())
 return actions
 # Return the body language of the pou given by its name
-def GetActionBodyType(self, pou_name, pou_action, debug = False):
+def GetActionBodyType(self, pou_name, pou_action, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the pou correponding to name and return its body language
 pou = project.getpou(pou_name)
 if pou is not None:
 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)
+extensions={("var_infos_ns", name): getattr(factory, name)
 for name in ["SetType", "AddDimension", "AddTree",
 "AddVarToTree", "AddVariable"]})
 variables_infos_xslt_tree(object_with_vars,
 tree=etree.XSLT.strparam(str(tree)))
 configuration.setglobalVars([
 varlist for vartype, varlist
 in self.ExtractVarLists(vars)])
 # Return the configuration globalvars
-def GetConfigurationGlobalVars(self, name, debug = False):
+def GetConfigurationGlobalVars(self, name, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the configuration corresponding to name
 configuration = project.getconfiguration(name)
 if configuration is not None:
 return self.GetVariableDictionary(configuration, debug)
 return []
 # Return configuration variable names
-def GetConfigurationVariableNames(self, config_name = None, debug = False):
+def GetConfigurationVariableNames(self, config_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():
 resource.setglobalVars([
 varlist for vartype, varlist
 in self.ExtractVarLists(vars)])
 # Return the resource globalvars
-def GetConfigurationResourceGlobalVars(self, config_name, name, debug = False):
+def GetConfigurationResourceGlobalVars(self, config_name, name, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 # Found the resource corresponding to name
 resource = project.getconfigurationResource(config_name, name)
 if resource is not None:
 return []
 # Return resource variable names
 def GetConfigurationResourceVariableNames(self,
-config_name = None, resource_name = None, debug = False):
+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 varlist in resource.globalVars],
 [])])
 return variables
 # Return the interface for the given pou
-def GetPouInterfaceVars(self, pou, tree=False, debug = False):
+def GetPouInterfaceVars(self, pou, tree=False, debug=False):
 interface = pou.interface
 # Verify that the pou has an interface
 if interface is not None:
 # Extract variables defined in interface
 return self.GetVariableDictionary(interface, tree, debug)
 return_type_infos_xslt_tree = etree.XSLT(
 etree.parse(
 os.path.join(ScriptDirectory, "plcopen", "variables_infos.xslt"),
 parser),
-extensions = {("var_infos_ns", name): getattr(factory, name)
+extensions={("var_infos_ns", name): getattr(factory, name)
 for name in ["SetType", "AddDimension",
 "AddTree", "AddVarToTree"]})
 return_type_infos_xslt_tree(return_type,
 tree=etree.XSLT.strparam(str(tree)))
 if tree:
 def ClearConfNodeTypes(self):
 self.ConfNodeTypes = []
 self.TotalTypesDict = StdBlckDct.copy()
 self.TotalTypes = StdBlckLst[:]
-def GetConfNodeDataTypes(self, exclude = None, only_locatables = False):
+def GetConfNodeDataTypes(self, exclude=None, only_locatables=False):
 return [{"name": _("%s Data Types") % confnodetypes["name"],
 "list": [
 datatype.getname()
 for datatype in confnodetypes["types"].getdataTypes()
 if not only_locatables or self.IsLocatableDataType(datatype, debug)]}
 global_vars.append(tempvar)
 return global_vars
 # Function that returns the block definition associated to the block type given
-def GetBlockType(self, typename, inputs = None, debug = False):
+def GetBlockType(self, typename, inputs=None, debug=False):
 result_blocktype = None
 for sectioname, blocktype in self.TotalTypesDict.get(typename, []):
 if inputs is not None and inputs != "undefined":
 block_inputs = tuple([var_type for name, var_type, modifier in blocktype["inputs"]])
 if reduce(lambda x, y: x and y, map(lambda x: x[0] == "ANY" or self.IsOfType(*x), zip(inputs, block_inputs)), True):
 return blocktype_infos
 return None
 # Return Block types checking for recursion
-def GetBlockTypes(self, tagname = "", debug = False):
+def GetBlockTypes(self, tagname="", debug=False):
 typename = None
 words = tagname.split("::")
 name = None
 project = self.GetProject(debug)
 if project is not None:
 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):
+def GetFunctionBlockTypes(self, tagname="", debug=False):
 project = self.GetProject(debug)
 words = tagname.split("::")
 name = None
 if project is not None and words[0] in ["P", "T", "A"]:
 name = words[1]
 if (name is None or
 len(self.GetInstanceList(pou, name, debug)) == 0)])
 return blocktypes
 # Return Block types checking for recursion
-def GetBlockResource(self, debug = False):
+def GetBlockResource(self, debug=False):
 blocktypes = []
 for category in StdBlckLst[:-1]:
 for blocktype in category["list"]:
 if blocktype["type"] == "program":
 blocktypes.append(blocktype["name"])
 [pou.getname()
 for pou in project.getpous(filter=["program"])])
 return blocktypes
 # Return Data Types checking for recursion
-def GetDataTypes(self, tagname = "", basetypes = True, confnodetypes = True, only_locatables = False, debug = False):
+def GetDataTypes(self, tagname="", basetypes=True, confnodetypes=True, only_locatables=False, debug=False):
 if basetypes:
 datatypes = self.GetBaseTypes()
 else:
 datatypes = []
 project = self.GetProject(debug)
 for category in self.GetConfNodeDataTypes(name, only_locatables):
 datatypes.extend(category["list"])
 return datatypes
 # Return Data Type Object
-def GetPou(self, typename, debug = False):
+def GetPou(self, typename, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 result = project.getpou(typename)
 if result is not None:
 return result
 if result is not None:
 return result
 return None
 # Return Data Type Object
-def GetDataType(self, typename, debug = False):
+def GetDataType(self, typename, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 result = project.getdataType(typename)
 if result is not None:
 return result
 return (basetype_content.getname() if basetype_content_type == "derived"
 else basetype_content_type.upper())
 return None
 # Return Base Type of given possible derived type
-def GetBaseType(self, typename, debug = False):
+def GetBaseType(self, typename, debug=False):
 if TypeHierarchy.has_key(typename):
 return typename
 datatype = self.GetDataType(typename, debug)
 if datatype is not None:
 TypeHierarchy_list has a rough order to it (e.g. SINT, INT, DINT, ...),
 which makes it easy for a user to find a type in a menu.
 '''
 return [x for x, y in TypeHierarchy_list if not x.startswith("ANY")]
-def IsOfType(self, typename, reference, debug = False):
+def IsOfType(self, typename, reference, debug=False):
 if reference is None or typename == reference:
 return True
 basetype = TypeHierarchy.get(typename)
 if basetype is not None:
 def IsEndType(self, typename):
 if typename is not None:
 return not typename.startswith("ANY")
 return True
-def IsLocatableDataType(self, datatype, debug = False):
+def IsLocatableDataType(self, datatype, debug=False):
 basetype_content = datatype.baseType.getcontent()
 basetype_content_type = basetype_content.getLocalTag()
 if basetype_content_type in ["enum", "struct"]:
 return False
 elif basetype_content_type == "derived":
 array_base_type = basetype_content.baseType.getcontent()
 if array_base_type.getLocalTag() == "derived":
 return self.IsLocatableType(array_base_type.getname(), debug)
 return True
-def IsLocatableType(self, typename, debug = False):
+def IsLocatableType(self, typename, debug=False):
 if isinstance(typename, TupleType) or self.GetBlockType(typename) is not None:
 return False
 # the size of these types is implementation dependend
 if typename in ["TIME", "DATE", "DT", "TOD"]:
 datatype = self.GetDataType(typename, debug)
 if datatype is not None:
 return self.IsLocatableDataType(datatype)
 return True
-def IsEnumeratedType(self, typename, debug = False):
+def IsEnumeratedType(self, typename, debug=False):
 if isinstance(typename, TupleType):
 typename = typename[1]
 datatype = self.GetDataType(typename, debug)
 if datatype is not None:
 basetype_content = datatype.baseType.getcontent()
 if basetype_content_type == "derived":
 return self.IsEnumeratedType(basetype_content_type, debug)
 return basetype_content_type == "enum"
 return False
-def IsSubrangeType(self, typename, exclude=None, debug = False):
+def IsSubrangeType(self, typename, exclude=None, debug=False):
 if typename == exclude:
 return False
 if isinstance(typename, TupleType):
 typename = typename[1]
 datatype = self.GetDataType(typename, debug)
 elif basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]:
 return not self.IsOfType(
 self.GetDataTypeBaseType(datatype), exclude)
 return False
-def IsNumType(self, typename, debug = False):
+def IsNumType(self, typename, debug=False):
 return self.IsOfType(typename, "ANY_NUM", debug) or\
 self.IsOfType(typename, "ANY_BIT", debug)
-def GetDataTypeRange(self, typename, debug = False):
+def GetDataTypeRange(self, typename, debug=False):
 range = DataTypeRange.get(typename)
 if range is not None:
 return range
 datatype = self.GetDataType(typename, debug)
 if datatype is not None:
 elif basetype_content_type == "derived":
 return self.GetDataTypeRange(basetype_content.getname(), debug)
 return None
 # Return Subrange types
-def GetSubrangeBaseTypes(self, exclude, debug = False):
+def GetSubrangeBaseTypes(self, exclude, debug=False):
 subrange_basetypes = DataTypeRange.keys()
 project = self.GetProject(debug)
 if project is not None:
 subrange_basetypes.extend(
 [datatype.getname() for datatype in project.getdataTypes()
 [datatype.getname() for datatype in confnodetype["types"].getdataTypes()
 if self.IsSubrangeType(datatype.getname(), exclude, debug)])
 return subrange_basetypes
 # Return Enumerated Values
-def GetEnumeratedDataValues(self, typename = None, debug = False):
+def GetEnumeratedDataValues(self, typename=None, debug=False):
 values = []
 if typename is not None:
 datatype_obj = self.GetDataType(typename, debug)
 if datatype_obj is not None:
 basetype_content = datatype_obj.baseType.getcontent()
 #-------------------------------------------------------------------------------
 #                    Project opened Data types management functions
 #-------------------------------------------------------------------------------
 # Return the data type informations
-def GetDataTypeInfos(self, tagname, debug = False):
+def GetDataTypeInfos(self, tagname, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 words = tagname.split("::")
 if words[0] == "D":
 infos = {}
 #-------------------------------------------------------------------------------
 #                       Project opened Pous management functions
 #-------------------------------------------------------------------------------
 # Return edited element
-def GetEditedElement(self, tagname, debug = False):
+def GetEditedElement(self, tagname, debug=False):
 project = self.GetProject(debug)
 if project is not None:
 words = tagname.split("::")
 if words[0] == "D":
 return project.getdataType(words[1])
 else:
 return words[2]
 return None
 # Return edited element name and type
-def GetEditedElementType(self, tagname, debug = False):
+def GetEditedElementType(self, tagname, debug=False):
 words = tagname.split("::")
 if words[0] in ["P", "T", "A"]:
 return words[1], self.GetPouType(words[1], debug)
 return None, None
 # Return language in which edited element is written
-def GetEditedElementBodyType(self, tagname, debug = False):
+def GetEditedElementBodyType(self, tagname, debug=False):
 words = tagname.split("::")
 if words[0] == "P":
 return self.GetPouBodyType(words[1], debug)
 elif words[0] == 'T':
 return self.GetTransitionBodyType(words[1], words[2], debug)
 elif words[0] == 'A':
 return self.GetActionBodyType(words[1], words[2], debug)
 return None
 # Return the edited element variables
-def GetEditedElementInterfaceVars(self, tagname, tree=False, debug = False):
+def GetEditedElementInterfaceVars(self, tagname, tree=False, debug=False):
 words = tagname.split("::")
 if words[0] in ["P", "T", "A"]:
 project = self.GetProject(debug)
 if project is not None:
 pou = project.getpou(words[1])
 if pou is not None:
 return self.GetPouInterfaceVars(pou, tree, debug)
 return []
 # Return the edited element return type
-def GetEditedElementInterfaceReturnType(self, tagname, tree=False, debug = False):
+def GetEditedElementInterfaceReturnType(self, tagname, tree=False, debug=False):
 words = tagname.split("::")
 if words[0] == "P":
 project = self.GetProject(debug)
 if project is not None:
 pou = self.Project.getpou(words[1])
 element = self.GetEditedElement(tagname)
 if element is not None:
 element.settext(text)
 # Return the edited element text
-def GetEditedElementText(self, tagname, debug = False):
+def GetEditedElementText(self, tagname, debug=False):
 element = self.GetEditedElement(tagname, debug)
 if element is not None:
 return element.gettext()
 return ""
 # Return the edited element transitions
-def GetEditedElementTransitions(self, tagname, debug = False):
+def GetEditedElementTransitions(self, tagname, debug=False):
 pou = self.GetEditedElement(tagname, debug)
 if pou is not None and pou.getbodyType() == "SFC":
 transitions = []
 for transition in pou.gettransitionList():
 transitions.append(transition.getname())
 return transitions
 return []
 # Return edited element transitions
-def GetEditedElementActions(self, tagname, debug = False):
+def GetEditedElementActions(self, tagname, debug=False):
 pou = self.GetEditedElement(tagname, debug)
 if pou is not None and pou.getbodyType() == "SFC":
 actions = []
 for action in pou.getactionList():
 actions.append(action.getname())
 return actions
 return []
 # Return the names of the pou elements
-def GetEditedElementVariables(self, tagname, debug = False):
+def GetEditedElementVariables(self, tagname, debug=False):
 words = tagname.split("::")
 if words[0] in ["P", "T", "A"]:
 return self.GetProjectPouVariableNames(words[1], debug)
 elif words[0] in ["C", "R"]:
 names = self.GetConfigurationVariableNames(words[1], debug)
 names.extend(self.GetConfigurationResourceVariableNames(
 words[1], words[2], debug))
 return names
 return []
-def GetEditedElementCopy(self, tagname, debug = False):
+def GetEditedElementCopy(self, tagname, debug=False):
 element = self.GetEditedElement(tagname, debug)
 if element is not None:
 return element.tostring()
 return ""
-def GetEditedElementInstancesCopy(self, tagname, blocks_id = None, wires = None, debug = False):
+def GetEditedElementInstancesCopy(self, tagname, blocks_id=None, wires=None, debug=False):
 element = self.GetEditedElement(tagname, debug)
 text = ""
 if element is not None:
 wires = dict([(wire, True)
 for wire in wires
 instance.setexecutionOrderId(0)
 instance.translate(*diff)
 return new_id, connections
-def GetEditedElementInstancesInfos(self, tagname, debug = False):
+def GetEditedElementInstancesInfos(self, tagname, debug=False):
 element_instances = OrderedDict()
 element = self.GetEditedElement(tagname, debug)
 if element is not None:
 factory = BlockInstanceFactory(element_instances)
 pou_block_instances_xslt_tree = etree.XSLT(
 pou_block_instances_xslt,
-extensions = {
+extensions={
 ("pou_block_instances_ns", name): getattr(factory, name)
 for name in ["AddBlockInstance", "SetSpecificValues",
 "AddInstanceConnection", "AddConnectionLink",
 "AddLinkPoint", "AddAction"]})
 if words[0] in ['P', 'T', 'A']:
 pou = self.Project.getpou(words[1])
 if pou is not None:
 pou.removepouVar(type, name)
-def AddEditedElementBlock(self, tagname, id, blocktype, blockname = None):
+def AddEditedElementBlock(self, tagname, id, blocktype, blockname=None):
 element = self.GetEditedElement(tagname)
 if element is not None:
 block = PLCOpenParser.CreateElement("block", "fbdObjects")
 block.setlocalId(id)
 block.settypeName(blocktype)
 instance = element.getinstance(id)
 if isinstance(instance, PLCOpenParser.GetElementClass("block", "fbdObjects")):
 self.RemoveEditedElementPouVar(tagname, instance.gettypeName(), instance.getinstanceName())
 element.removeinstance(id)
-def GetEditedResourceVariables(self, tagname, debug = False):
+def GetEditedResourceVariables(self, tagname, debug=False):
 varlist = []
 words = tagname.split("::")
 for var in self.GetConfigurationGlobalVars(words[1], debug):
 if var.Type == "BOOL":
 varlist.append(var.Name)
 new_instance = PLCOpenParser.CreateElement("pouInstance", "resource")
 resource.appendpouInstance(new_instance)
 new_instance.setname(instance["Name"])
 new_instance.settypeName(instance["Type"])
-def GetEditedResourceInfos(self, tagname, debug = False):
+def GetEditedResourceInfos(self, tagname, debug=False):
 resource = self.GetEditedElement(tagname, debug)
 if resource is not None:
 tasks = resource.gettask()
 instances = resource.getpouInstance()
 tasks_data = []
 self.CurrentCompiledProject = None
 self.Buffering = False
 self.CurrentElementEditing = None
 return error
-def SaveXMLFile(self, filepath = None):
+def SaveXMLFile(self, filepath=None):
 if not filepath and self.FilePath == "":
 return False
 else:
 contentheader = {"modificationDateTime": datetime.datetime(*localtime()[:6])}
 self.Project.setcontentHeader(contentheader)

changeset 1744	69dfdb26f600
parent 1743	c3c3d1318130
child 1749	d73b64672238