def createOutputPin(self,
pinName,
dataType,
defaultValue=None,
foo=None,
structure=PinStructure.Single,
constraint=None,
structConstraint=None,
allowedPins=[]):
pinName = self.getUniqPinName(pinName)
p = CreateRawPin(pinName, self, dataType, PinDirection.Output)
p.structureType = structure
if structure == PinStructure.Array:
p.initAsArray(True)
elif structure == PinStructure.Multi:
p.enableOptions(PinOptions.ArraySupported)
if foo:
p.onExecute.connect(foo, weak=False)
if defaultValue is not None:
p.setDefaultValue(defaultValue)
p.setData(defaultValue)
if dataType == "AnyPin" and allowedPins:
def supportedDataTypes():
return allowedPins
p.supportedDataTypes = supportedDataTypes
if constraint is not None:
p.updateConstraint(constraint)
if structConstraint is not None:
p.updatestructConstraint(structConstraint)
return p
def createOutputPin(self,
pinName,
dataType,
defaultValue=None,
structure=PinStructure.Single,
constraint=None,
structConstraint=None,
supportedPinDataTypes=[],
group=""):
"""Creates output pin
:param pinName: Pin name
:type pinName: str
:param dataType: Pin data type
:type dataType: str
:param defaultValue: Pin default value
:type defaultValue: object
:param structure: Pin structure
:type structure: :class:`~PyFlow.Core.Common.PinStructure.Single`
:param constraint: Pin constraint. Should be any hashable type. We use str
:type constraint: object
:param structConstraint: Pin struct constraint. Also should be hashable type
:type structConstraint: object
:param supportedPinDataTypes: List of allowed pin data types to be connected. Used by AnyPin
:type supportedPinDataTypes: list(str)
:param group: Pin group. Used only by ui wrapper
:type group: str
"""
pinName = self.getUniqPinName(pinName)
p = CreateRawPin(pinName, self, dataType, PinDirection.Output)
p.structureType = structure
p.group = group
if structure == PinStructure.Array:
p.initAsArray(True)
elif structure == PinStructure.Dict:
p.initAsDict(True)
elif structure == PinStructure.Multi:
p.enableOptions(PinOptions.ArraySupported)
if defaultValue is not None or dataType == "AnyPin":
p.setDefaultValue(defaultValue)
p.setData(defaultValue)
if dataType == "AnyPin":
p.setTypeFromData(defaultValue)
else:
p.setDefaultValue(getPinDefaultValueByType(dataType))
if dataType == "AnyPin" and supportedPinDataTypes:
def supportedDataTypes():
return supportedPinDataTypes
p.supportedDataTypes = supportedDataTypes
if constraint is not None:
p.updateConstraint(constraint)
if structConstraint is not None:
p.updateStructConstraint(structConstraint)
return p
class setVar(NodeBase):
def __init__(self, name, var=None):
super(setVar, self).__init__(name)
self.inExec = self.createInputPin(DEFAULT_IN_EXEC_NAME, 'ExecPin',
None, self.compute)
self.outExec = self.createOutputPin(DEFAULT_OUT_EXEC_NAME, 'ExecPin')
self.var = var
self.inp = CreateRawPin("value", self, self.var.dataType,
PinDirection.Input)
self.inp.disableOptions(PinOptions.RenamingEnabled)
self.out = CreateRawPin("value", self, self.var.dataType,
PinDirection.Output)
self.out.disableOptions(PinOptions.RenamingEnabled)
def recreateInput(self, dataType):
self.inp.kill()
del self.inp
self.inp = None
self.inp = CreateRawPin('value', self, dataType, PinDirection.Input)
self.inp.disableOptions(PinOptions.RenamingEnabled)
return self.out
def recreateOutput(self, dataType):
self.out.kill()
del self.out
self.out = None
self.out = CreateRawPin('value', self, dataType, PinDirection.Output)
self.out.disableOptions(PinOptions.RenamingEnabled)
return self.out
def variableUid(self):
return self.var.uid
def serialize(self):
default = NodeBase.serialize(self)
default['varUid'] = str(self.var.uid)
return default
@staticmethod
def pinTypeHints():
return {'inputs': [], 'outputs': []}
@staticmethod
def category():
return PACKAGE_NAME
@staticmethod
def keywords():
return ["set", "var"]
@staticmethod
def description():
return 'Set variable value'
def compute(self, *args, **kwargs):
newValue = self.inp.getData()
self.var.value = newValue
self.out.setData(copy(self.var.value))
self.outExec.call(*args, **kwargs)
class getVar(NodeBase):
def __init__(self, name, var=None):
super(getVar, self).__init__(name)
assert (isinstance(var, Variable))
self.var = var
self.out = CreateRawPin('value', self, var.dataType,
PinDirection.Output)
self.out.enableOptions(PinOptions.RenamingEnabled)
self.var.valueChanged.connect(self.onVarValueChanged)
self.var.killed.connect(self.kill)
def variableUid(self):
return self.var.uid
def recreateOutput(self, dataType):
self.out.kill()
del self.out
self.out = None
self.out = CreateRawPin('value', self, dataType, PinDirection.Output)
self.out.enableOptions(PinOptions.RenamingEnabled)
return self.out
def onVarValueChanged(self, *args, **kwargs):
push(self.out)
def serialize(self):
default = NodeBase.serialize(self)
default['varUid'] = str(self.var.uid)
return default
@staticmethod
def pinTypeHints():
return {'inputs': [], 'outputs': []}
@staticmethod
def category():
return PACKAGE_NAME
@staticmethod
def keywords():
return ["get", "var"]
@staticmethod
def description():
return 'Access variable value'
def compute(self, *args, **kwargs):
self.out.setData(copy(self.var.value))
def createInputPin(self,
pinName,
dataType,
defaultValue=None,
foo=None,
structure=PinStructure.Single,
constraint=None,
structConstraint=None,
allowedPins=[],
group=""):
# check unique name
pinName = self.getUniqPinName(pinName)
p = CreateRawPin(pinName, self, dataType, PinDirection.Input)
p.structureType = structure
p.group = group
if structure == PinStructure.Array:
p.initAsArray(True)
elif structure == PinStructure.Dict:
p.initAsDict(True)
elif structure == PinStructure.Multi:
p.enableOptions(PinOptions.ArraySupported)
if foo:
p.onExecute.connect(foo, weak=False)
if defaultValue is not None or dataType == "AnyPin":
p.setDefaultValue(defaultValue)
p.setData(defaultValue)
if dataType == "AnyPin":
p.setTypeFromData(defaultValue)
else:
p.setDefaultValue(getPinDefaultValueByType(dataType))
if dataType == "AnyPin" and allowedPins:
def supportedDataTypes():
return allowedPins
p._supportedDataTypes = p._defaultSupportedDataTypes = tuple(
allowedPins)
p.supportedDataTypes = supportedDataTypes
if constraint is not None:
p.updateConstraint(constraint)
if structConstraint is not None:
p.updatestructConstraint(structConstraint)
return p
def createInputPin(self,
pinName,
dataType,
defaultValue=None,
foo=None,
structure=PinStructure.Single,
constraint=None,
structConstraint=None,
allowedPins=[]):
# if dataType == 'ExecPin':
# assert(foo is not None), "Invalid parameters for input exec pin. Call function must be specified"
# check unique name
pinName = self.getUniqPinName(pinName)
p = CreateRawPin(pinName, self, dataType, PinDirection.Input)
p.direction = PinDirection.Input
p.structureType = structure
if structure == PinStructure.Array:
p.initAsArray(True)
elif structure == PinStructure.Multi:
p.enableOptions(PinOptions.ArraySupported)
if foo:
# p.call = foo
p.onExecute.connect(foo, weak=False)
if defaultValue is not None:
p.setDefaultValue(defaultValue)
p.setData(defaultValue)
if dataType == "AnyPin" and allowedPins:
def supportedDataTypes():
return allowedPins
p._supportedDataTypes = p._defaultSupportedDataTypes = tuple(
allowedPins)
p.supportedDataTypes = supportedDataTypes
if constraint is not None:
p.updateConstraint(constraint)
if structConstraint is not None:
p.updatestructConstraint(structConstraint)
return p
class getVar(NodeBase):
def __init__(self, name, var=None):
super(getVar, self).__init__(name)
assert (isinstance(var, Variable))
self._var = var
if var.structure == StructureType.Dict:
self.out = self.createOutputPin('out',
var.value.keyType,
structure=StructureType.Dict)
else:
self.out = self.createOutputPin('out', var.dataType)
self.out.disableOptions(PinOptions.RenamingEnabled)
self._var.valueChanged.connect(self.onVarValueChanged)
self._var.structureChanged.connect(self.onVarStructureChanged)
self._var.dataTypeChanged.connect(self.onDataTypeChanged)
self.bCacheEnabled = False
def checkForErrors(self):
super(getVar, self).checkForErrors()
if self._var is None:
self.setError("Undefined variable")
def onDataTypeChanged(self, dataType):
self.recreateOutput(dataType)
self.checkForErrors()
wrapper = self.getWrapper()
if wrapper:
wrapper.onVariableWasChanged()
def updateStructure(self):
self.out.disconnectAll()
if self._var.structure == StructureType.Single:
self.out.setAsArray(False)
if self._var.structure == StructureType.Array:
self.out.setAsArray(True)
if self._var.structure == StructureType.Dict:
self.out.setAsDict(True)
# self.out._keyType = self.var.value.keyType
def onVarStructureChanged(self, newStructure):
self.out.structureType = newStructure
self.updateStructure()
def recreateOutput(self, dataType):
self.out.kill()
del self.out
self.out = None
self.out = CreateRawPin('out', self, dataType, PinDirection.Output)
self.out.disableOptions(PinOptions.RenamingEnabled)
self.updateStructure()
return self.out
@property
def var(self):
return self._var
@var.setter
def var(self, newVar):
if self._var is not None:
self._var.dataTypeChanged.disconnect(self.onDataTypeChanged)
self._var.structureChanged.disconnect(self.onVarStructureChanged)
self._var.valueChanged.disconnect(self.onVarValueChanged)
self._var = newVar
if newVar is not None:
self._var.valueChanged.connect(self.onVarValueChanged)
self._var.structureChanged.connect(self.onVarStructureChanged)
self._var.dataTypeChanged.connect(self.onDataTypeChanged)
self.recreateOutput(self._var.dataType)
else:
# self.out.kill()
# del self.out
# self.out = None
pass
self.checkForErrors()
wrapper = self.getWrapper()
if wrapper:
wrapper.onVariableWasChanged()
def postCreate(self, jsonTemplate=None):
super(getVar, self).postCreate(jsonTemplate)
self.updateStructure()
def variableUid(self):
return self.var.uid
def onVarValueChanged(self, *args, **kwargs):
push(self.out)
def serialize(self):
default = NodeBase.serialize(self)
if self.var is not None:
default['varUid'] = str(self.var.uid)
return default
@staticmethod
def category():
return PACKAGE_NAME
@staticmethod
def keywords():
return ["get", "var"]
@staticmethod
def description():
return 'Access variable value'
def compute(self, *args, **kwargs):
self.out.setData(copy(self.var.value))
def createInputPin(self,
pinName,
dataType,
defaultValue=None,
foo=None,
structure=StructureType.Single,
constraint=None,
structConstraint=None,
supportedPinDataTypes=[],
group=""):
"""Creates input pin
:param pinName: Pin name
:type pinName: str
:param dataType: Pin data type
:type dataType: str
:param defaultValue: Pin default value
:type defaultValue: object
:param foo: Pin callback. used for exec pins
:type foo: function
:param structure: Pin structure
:type structure: :class:`~PyFlow.Core.Common.StructureType.Single`
:param constraint: Pin constraint. Should be any hashable type. We use str
:type constraint: object
:param structConstraint: Pin struct constraint. Also should be hashable type
:type structConstraint: object
:param supportedPinDataTypes: List of allowed pin data types to be connected. Used by AnyPin
:type supportedPinDataTypes: list(str)
:param group: Pin group. Used only by ui wrapper
:type group: str
"""
pinName = self.getUniqPinName(pinName)
p = CreateRawPin(pinName, self, dataType, PinDirection.Input)
p.structureType = structure
p.group = group
if structure == StructureType.Array:
p.initAsArray(True)
elif structure == StructureType.Dict:
p.initAsDict(True)
elif structure == StructureType.Multi:
p.enableOptions(PinOptions.ArraySupported)
if foo:
p.onExecute.connect(foo, weak=False)
if defaultValue is not None or dataType == "AnyPin":
p.setDefaultValue(defaultValue)
p.setData(defaultValue)
if dataType == "AnyPin":
p.setTypeFromData(defaultValue)
else:
p.setDefaultValue(getPinDefaultValueByType(dataType))
if dataType == "AnyPin" and supportedPinDataTypes:
def supportedDataTypes():
return supportedPinDataTypes
p._supportedDataTypes = p._defaultSupportedDataTypes = tuple(
supportedPinDataTypes)
p.supportedDataTypes = supportedDataTypes
if constraint is not None:
p.updateConstraint(constraint)
if structConstraint is not None:
p.updateStructConstraint(structConstraint)
p.dataBeenSet.connect(self.setDirty.send)
p.markedAsDirty.connect(self.setDirty.send)
return p
def runraw(self):
sayl("#+")
# called biy FreeCAD_Object createpins
objname=self.objname.getData()
fobj=FreeCAD.ActiveDocument.getObject(objname)
if fobj == None:
say("cannot create pins because no FreeCAD object for name {}".format(objname))
return []
ps=fobj.PropertiesList
if 10:
sayl('#')
say("FreeCAD object Properties ---")
for p in ps:
say (p)
pins=[]
ipm=self.namePinInputsMap
if 0:
say("ipm.keys() for ",objname,fobj.Name,fobj.Label)
for k in ipm.keys():
say(k)
#---------------
recomputepins=[]
for p in ps:
say("X",p)
try:
a=getattr(fobj,p)
except:
say ("ignore problem with prop",p," fix it later !!")
continue
if p in ["Placement","Shape",
"MapMode",
"MapReversed","MapPathParameter",
"Attacher",
"AttacherType",
"AttachmentOffset","ExpressionEngine","Support"]:
pass
continue
if p in ipm.keys():
print("IGNORE '{}' - exists already".format(p))
continue
cn=a.__class__.__name__
if p.startswith("aLink"):
# zu tun
continue
# print("################",cn,p,a)
if cn=="list" and p.endswith('List'):
r2=p.replace('List','Pin')
r=r2[1:]
# say("--------------",p,r,r2)
if r=="IntegerPin":
r="IntPin"
try:
p1 = self.createInputPin(p, r ,[],structure=PinStructure.Array)
p2 = self.createOutputPin(p+"_out", r ,[],structure=PinStructure.Array)
pins += [p1,p2]
except:
say("cannot create list pin for",p,r2)
continue
if cn=="Quantity" or cn=="float":
pintyp="FloatPin"
elif cn=="Vector":
pintyp="VectorPin"
elif cn=="str" or cn=="unicode":
pintyp="StringPin"
elif cn=="bool":
pintyp="BoolPin"
elif cn=="int":
pintyp="IntPin"
elif cn=="Placement":
pintyp="PlacementPin"
elif cn=="Rotation":
pintyp="RotationPin"
elif cn=='list' or cn == 'dict' or cn=='tuple' or cn=='set':
# zu tun
continue
elif cn=='Material' or cn=='Shape' or cn=='Matrix' : # zu tun
continue
elif cn=='NoneType' :
# zu tun
continue
else:
say(p,cn,a,"is not known")
continue
say("-----------------")
pinname=p
pinval=a
say("create pin for ",pintyp,pinname,pinval)
'''
if pinname not in oldpinnames:
pintyp="ShapePin"
p2 = CreateRawPin(pinname,self, pintyp, PinDirection.Output)
try:
uiPin = self.getWrapper()._createUIPinWrapper(p2)
uiPin.setDisplayName("{}".format(p2.name))
except:
pass
self.setPinObject(pinname,subob)
'''
p1 = CreateRawPin(pinname,self, pintyp, PinDirection.Input)
p2 = CreateRawPin(pinname+"_out",self, pintyp, PinDirection.Output)
try:
uiPin = self.getWrapper()._createUIPinWrapper(p2)
uiPin.setDisplayName("{}".format(p2.name))
except:
pass
try:
uiPin = self.getWrapper()._createUIPinWrapper(p1)
uiPin.setDisplayName("{}".format(p1.name))
except:
pass
p1.enableOptions(PinOptions.Dynamic)
# p1.recomputeNode=True
recomputepins += [p1]
try:
p1.setData(pinval)
p2.setData(pinval)
except:
say("problem setting",p)
say("created:",p1)
pins += [p1,p2]
sayl()
for p in recomputepins:
p.recomputeNode=True
for p in pins:
p.group="FOP"
sh=fobj.Shape
self.setPinObject("Shape_out",sh)
return pins
class setVar(NodeBase):
def __init__(self, name, var=None):
super(setVar, self).__init__(name)
self.inExec = self.createInputPin(DEFAULT_IN_EXEC_NAME, 'ExecPin',
None, self.compute)
self.outExec = self.createOutputPin(DEFAULT_OUT_EXEC_NAME, 'ExecPin')
self._var = var
self.inp = CreateRawPin("inp", self, self._var.dataType,
PinDirection.Input)
self.inp.disableOptions(PinOptions.RenamingEnabled)
self.out = CreateRawPin("out", self, self._var.dataType,
PinDirection.Output)
self.out.disableOptions(PinOptions.RenamingEnabled)
self._var.dataTypeChanged.connect(self.onVarDataTypeChanged)
self._var.structureChanged.connect(self.onVarStructureChanged)
def updateStructure(self):
self.out.disconnectAll()
self.inp.disconnectAll()
if self.var.structure == PinStructure.Single:
self.out.setAsArray(False)
self.inp.setAsArray(False)
if self.var.structure == PinStructure.Array:
self.out.setAsArray(True)
self.inp.setAsArray(True)
def checkForErrors(self):
super(setVar, self).checkForErrors()
if self._var is None:
self.setError("Undefined variable")
def onVarStructureChanged(self, newStructure):
self.out.structureType = newStructure
self.inp.structureType = newStructure
self.updateStructure()
def onVarDataTypeChanged(self, dataType):
self.recreateInput(dataType)
self.recreateOutput(dataType)
self.autoAffectPins()
self.updateStructure()
self.checkForErrors()
wrapper = self.getWrapper()
if wrapper:
wrapper.onVariableWasChanged()
def postCreate(self, jsonTemplate=None):
super(setVar, self).postCreate(jsonTemplate)
self.updateStructure()
@property
def var(self):
return self._var
@var.setter
def var(self, newVar):
if self._var is not None:
self._var.structureChanged.disconnect(self.onVarStructureChanged)
self._var.dataTypeChanged.disconnect(self.onVarDataTypeChanged)
self._var = newVar
if self._var is not None:
self._var.structureChanged.connect(self.onVarStructureChanged)
self._var.dataTypeChanged.connect(self.onVarDataTypeChanged)
self.recreateInput(newVar.dataType)
self.recreateOutput(newVar.dataType)
self.autoAffectPins()
self.updateStructure()
self.checkForErrors()
wrapper = self.getWrapper()
if wrapper:
wrapper.onVariableWasChanged()
def recreateInput(self, dataType):
self.inp.kill()
del self.inp
self.inp = None
self.inp = CreateRawPin('inp', self, dataType, PinDirection.Input)
self.inp.disableOptions(PinOptions.RenamingEnabled)
return self.inp
def recreateOutput(self, dataType):
self.out.kill()
del self.out
self.out = None
self.out = CreateRawPin('out', self, dataType, PinDirection.Output)
self.out.disableOptions(PinOptions.RenamingEnabled)
return self.out
def variableUid(self):
return self.var.uid
def serialize(self):
default = NodeBase.serialize(self)
default['varUid'] = str(self.var.uid)
return default
@staticmethod
def category():
return PACKAGE_NAME
@staticmethod
def keywords():
return ["set", "var"]
@staticmethod
def description():
return 'Set variable value'
def compute(self, *args, **kwargs):
newValue = self.inp.getData()
self.var.value = newValue
self.out.setData(copy(self.var.value))
self.outExec.call(*args, **kwargs)
