PyFlow.Packages.PyFlowBase.FunctionLibraries package

Submodules

PyFlow.Packages.PyFlowBase.FunctionLibraries.ArrayLib module

class PyFlow.Packages.PyFlowBase.FunctionLibraries.ArrayLib.ArrayLib(packageName)

Bases: PyFlow.Core.FunctionLibrary.FunctionLibraryBase

doc string for ArrayLib

__init__(packageName)

Initialize self. See help(type(self)) for accurate signature.

static arrayElementCount(ls: ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}) = ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}), element: ('AnyPin', None, {'constraint': '1', 'enabledOptions': <PinOptions.AllowAny: 512>}) = ('AnyPin', None, {'constraint': '1', 'enabledOptions': <PinOptions.AllowAny: 512>}), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('IntPin', 0)

Returns len of passed array.

static arrayElementIndex(ls: ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}) = ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}), element: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('IntPin', 0)

Returns index of array element if it present. If element is not in array -1 will be returned.

static arraySlice(ls: ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}) = ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}), start: ('IntPin', 0) = ('IntPin', 0), end: ('IntPin', 1) = ('IntPin', 1), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>})

Array slice.

static arraySum(Value: ('AnyPin', []{'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}) = ('AnyPin', []{'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']})) -> ('AnyPin', None, {'constraint': '1'})

Python sum() function.

static clearArray(ls: ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}) = ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>})) -> ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>})

Remove all items from the list.

static extendArray(lhs: ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}) = ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}), rhs: ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}) = ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>})) -> ('AnyPin', []{'constraint': '1'})

Extend the list by appending all the items from the iterable.

static insertToArray(ls: ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}) = ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}), elem: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), index: ('IntPin', 0) = ('IntPin', 0)) -> ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>})

Insert an item at a given position. The first argument is the index of the element before which to insert.

static popFromArray(ls: ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}) = ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}), index: ('IntPin', -1) = ('IntPin', -1), popped: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False)), outLs: ('Reference', ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>})) = ('Reference', ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}))) -> ('AnyPin', None, {'constraint': '1'})

Remove the item at the given position in the array, and return it. If no index is specified, a.pop() removes and returns the last item in the list.

static removeFromArray(ls: ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}) = ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}), elem: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), removed: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('AnyPin', []{'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>})

Remove the first item from the list whose value is equal to x.

PyFlow.Packages.PyFlowBase.FunctionLibraries.BoolLib module

class PyFlow.Packages.PyFlowBase.FunctionLibraries.BoolLib.BoolLib(packageName)

Bases: PyFlow.Core.FunctionLibrary.FunctionLibraryBase

doc string for BoolLib

__init__(packageName)

Initialize self. See help(type(self)) for accurate signature.

static boolAnd(a: ('BoolPin', False) = ('BoolPin', False), b: ('BoolPin', False) = ('BoolPin', False)) -> ('BoolPin', False)

Returns the logical AND of two values (A AND B).

static boolNand(a: ('BoolPin', False) = ('BoolPin', False), b: ('BoolPin', False) = ('BoolPin', False)) -> ('BoolPin', False)

Returns the logical NAND of two values (A AND B).

static boolNor(a: ('BoolPin', False) = ('BoolPin', False), b: ('BoolPin', False) = ('BoolPin', False)) -> ('BoolPin', False)

Returns the logical Not OR of two values (A NOR B).

static boolNot(a: ('BoolPin', False) = ('BoolPin', False)) -> ('BoolPin', False)

Returns the logical complement of the Boolean value (NOT A).

static boolOr(a: ('BoolPin', False) = ('BoolPin', False), b: ('BoolPin', False) = ('BoolPin', False)) -> ('BoolPin', False)

Returns the logical OR of two values (A OR B).

static boolXor(a: ('BoolPin', False) = ('BoolPin', False), b: ('BoolPin', False) = ('BoolPin', False)) -> ('BoolPin', False)

Returns the logical eXclusive OR of two values (A XOR B).

PyFlow.Packages.PyFlowBase.FunctionLibraries.DefaultLib module

class PyFlow.Packages.PyFlowBase.FunctionLibraries.DefaultLib.DefaultLib(packageName)

Bases: PyFlow.Core.FunctionLibrary.FunctionLibraryBase

Default library builting stuff, variable types and conversions

__init__(packageName)

Initialize self. See help(type(self)) for accurate signature.

static addTo(obj: ('AnyPin', None, {'constraint': '1', 'structConstraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}) = ('AnyPin', None, {'constraint': '1', 'structConstraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}), element: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), result: ('Reference', ('AnyPin', None, {'constraint': '1', 'structConstraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>})) = ('Reference', ('AnyPin', None, {'constraint': '1', 'structConstraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}))) -> ('BoolPin', False)

Calls obj.add(element). And returns object. If failed - object is unchanged

static appendTo(obj: ('AnyPin', None, {'constraint': '1', 'structConstraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}) = ('AnyPin', None, {'constraint': '1', 'structConstraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}), element: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('AnyPin', None, {'constraint': '1', 'structConstraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>})

Calls obj.append(element). And returns object. If failed - object is unchanged

static clearConsole() → None

Cross platform clears console.

static clock() -> ('FloatPin', 0.0, {'enabledOptions': <PinOptions.AlwaysPushDirty: 128>})

Returns the CPU time or real time since the start of the process or since the first call of process_time().

static contains(obj: ('AnyPin', None, {'constraint': '1', 'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>}) = ('AnyPin', None, {'constraint': '1', 'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>}), element: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'})) -> ('BoolPin', False)

Python’s in keyword. element in obj will be executed

static copyObject(obj: ('AnyPin', None, {'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>, 'constraint': '1', 'structConstraint': '1'}) = ('AnyPin', None, {'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>, 'constraint': '1', 'structConstraint': '1'}), deepCopy: ('BoolPin', False) = ('BoolPin', False)) -> ('AnyPin', None, {'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>, 'constraint': '1', 'structConstraint': '1'})

Shallow or deep copy of an object.

static getItem(obj: ('AnyPin', None, {'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}) = ('AnyPin', None, {'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>}), element: ('AnyPin', None, {'supportedDataTypes': []}) = ('AnyPin', None, {'supportedDataTypes': []}), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('AnyPin', None, {'constraint': '1', 'enabledOptions': <PinOptions.AllowAny|ArraySupported: 513>})

Python’s [] operator. obj[element] will be executed.

static len(obj: ('AnyPin', None, {'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>, 'Description': 'Iterable object'}) = ('AnyPin', None, {'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>, 'Description': 'Iterable object'})) -> ('IntPin', 0, {'Description': 'Number of elements of iterable'})

Python’s len function.

static makeBool(b: ('BoolPin', False) = ('BoolPin', False)) -> ('BoolPin', False)

Make boolean.

static makeFloat(f: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Make floating point number.

static makeInt(i: ('IntPin', 0) = ('IntPin', 0)) -> ('IntPin', 0)

Make integer.

static makePath(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('StringPin', '')

Make path.

static makeString(s: ('StringPin', '') = ('StringPin', '')) -> ('StringPin', '')

Make string.

static objectType(obj: ('AnyPin', None, {'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>}) = ('AnyPin', None, {'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>})) -> ('StringPin', '')

Returns type(obj).__name__

static select(A: ('AnyPin', None, {'constraint': '1', 'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>}) = ('AnyPin', None, {'constraint': '1', 'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>}), B: ('AnyPin', None, {'constraint': '1', 'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>}) = ('AnyPin', None, {'constraint': '1', 'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>}), PickA: ('BoolPin', False) = ('BoolPin', False), aPicked: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('AnyPin', None, {'constraint': '1', 'enabledOptions': <PinOptions.DictElementSupported|AllowAny|ArraySupported: 1537>})

If bPickA is true, A is returned, otherwise B.

PyFlow.Packages.PyFlowBase.FunctionLibraries.FloatLib module

class PyFlow.Packages.PyFlowBase.FunctionLibraries.FloatLib.FloatLib(packageName)

Bases: PyFlow.Core.FunctionLibrary.FunctionLibraryBase

doc string for FloatLib

__init__(packageName)

Initialize self. See help(type(self)) for accurate signature.

static lerpf(a: ('FloatPin', 0.0) = ('FloatPin', 0.0), b: ('FloatPin', 0.0) = ('FloatPin', 0.0), alpha: ('FloatPin', 0.0, {'ValueRange': (0.0, 1.0), 'DraggerSteps': [0.1, 0.01, 0.001]}) = ('FloatPin', 0.0, {'ValueRange': (0.0, 1.0), 'DraggerSteps': [0.1, 0.01, 0.001]})) -> ('FloatPin', 0.0)

Linear interpolate

static multByPi(a: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Multiplies the input value by pi.

static normalizeToRange(Value: ('FloatPin', 0.0) = ('FloatPin', 0.0), RangeMin: ('FloatPin', 0.0) = ('FloatPin', 0.0), RangeMax: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Returns Value normalized to the given range. (e.g. 20 normalized to the range 10->50 would result in 0.25)

static roundf(Value: ('FloatPin', 0.0) = ('FloatPin', 0.0), Digits: ('IntPin', 0, {'ValueRange': (0, 323)}) = ('IntPin', 0, {'ValueRange': (0, 323)})) -> ('FloatPin', 0.0)

Round a number to a given precision in decimal digits.

PyFlow.Packages.PyFlowBase.FunctionLibraries.IntLib module

class PyFlow.Packages.PyFlowBase.FunctionLibraries.IntLib.IntLib(packageName)

Bases: PyFlow.Core.FunctionLibrary.FunctionLibraryBase

doc string for IntLib

__init__(packageName)

Initialize self. See help(type(self)) for accurate signature.

static binaryLeftShift(a: ('IntPin', 0) = ('IntPin', 0), b: ('IntPin', 0) = ('IntPin', 0)) -> ('IntPin', 0)

Binary left shift a << b

static binaryRightShift(a: ('IntPin', 0) = ('IntPin', 0), b: ('IntPin', 0) = ('IntPin', 0)) -> ('IntPin', 0)

Binary right shift a << b

static bitwiseAnd(a: ('IntPin', 0) = ('IntPin', 0), b: ('IntPin', 0) = ('IntPin', 0)) -> ('IntPin', 0)

Bitwise AND (A & B)

static bitwiseNot(a: ('IntPin', 0) = ('IntPin', 0)) -> ('IntPin', 0)

Bitwise NOT (~A)

static bitwiseOr(a: ('IntPin', 0) = ('IntPin', 0), b: ('IntPin', 0) = ('IntPin', 0)) -> ('IntPin', 0)

Bitwise OR (A | B)

static bitwiseXor(a: ('IntPin', 0) = ('IntPin', 0), b: ('IntPin', 0) = ('IntPin', 0)) -> ('IntPin', 0)

Bitwise XOR (A ^ B)

static clearBit(intType: ('IntPin', 0) = ('IntPin', 0), offset: ('IntPin', 0) = ('IntPin', 0)) -> ('IntPin', 0)

Returns an integer with the bit at ‘offset’ cleared.

static setBit(intType: ('IntPin', 0) = ('IntPin', 0), offset: ('IntPin', 0) = ('IntPin', 0)) -> ('IntPin', 0)

Returns an integer with the bit at ‘offset’ set to 1.

static sign(x: ('IntPin', 0) = ('IntPin', 0)) -> ('IntPin', 0)

Sign (integer, returns -1 if A < 0, 0 if A is zero, and +1 if A > 0)

static testBit(intType: ('IntPin', 0) = ('IntPin', 0), offset: ('IntPin', 0) = ('IntPin', 0)) -> ('IntPin', 0)

Returns a nonzero result, 2**offset, if the bit at ‘offset’ is one

static toggleBit(intType: ('IntPin', 0) = ('IntPin', 0), offset: ('IntPin', 0) = ('IntPin', 0)) -> ('IntPin', 0)

Returns an integer with the bit at ‘offset’ inverted, 0 -> 1 and 1 -> 0.

PyFlow.Packages.PyFlowBase.FunctionLibraries.MathAbstractLib module

class PyFlow.Packages.PyFlowBase.FunctionLibraries.MathAbstractLib.MathAbstractLib(packageName)

Bases: PyFlow.Core.FunctionLibrary.FunctionLibraryBase

doc string for MathAbstractLib

__init__(packageName)

Initialize self. See help(type(self)) for accurate signature.

static abs(inp: ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}) = ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']})) -> ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']})

Return the absolute value of a number.

static add(a: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), b: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'})) -> ('AnyPin', None, {'constraint': '1'})

Operator +.

static clamp(i: ('FloatPin', 0.0) = ('FloatPin', 0.0), imin: ('FloatPin', 0.0) = ('FloatPin', 0.0), imax: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Clamp.

static divide(a: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), b: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'})) -> ('AnyPin', None, {'constraint': '1'})

Operator /.

static inRange(Value: ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}) = ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}), RangeMin: ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}) = ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}), RangeMax: ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}) = ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}), InclusiveMin: ('BoolPin', False) = ('BoolPin', False), InclusiveMax: ('BoolPin', False) = ('BoolPin', False)) -> ('BoolPin', False)

Returns true if value is between Min and Max (V >= Min && V <= Max) If InclusiveMin is true, value needs to be equal or larger than Min, else it needs to be larger If InclusiveMax is true, value needs to be smaller or equal than Max, else it needs to be smaller

static isEqual(a: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), b: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'})) -> ('BoolPin', False)

Is a equal b.

static isGreater(a: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), b: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('BoolPin', False)

Operator >.

static isGreaterOrEqual(a: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), b: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('BoolPin', False)

Operator >=.

static isLess(a: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), b: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('BoolPin', False)

Operator <.

static isLessOrEqual(a: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), b: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'})) -> ('BoolPin', False)

Operator <=.

static mapRangeClamped(Value: ('FloatPin', 0.0) = ('FloatPin', 0.0), InRangeA: ('FloatPin', 0.0) = ('FloatPin', 0.0), InRangeB: ('FloatPin', 0.0) = ('FloatPin', 0.0), OutRangeA: ('FloatPin', 0.0) = ('FloatPin', 0.0), OutRangeB: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Returns Value mapped from one range into another where the Value is clamped to the Input Range. (e.g. 0.5 normalized from the range 0->1 to 0->50 would result in 25)

static mapRangeUnclamped(Value: ('FloatPin', 0.0) = ('FloatPin', 0.0), InRangeA: ('FloatPin', 0.0) = ('FloatPin', 0.0), InRangeB: ('FloatPin', 0.0) = ('FloatPin', 0.0), OutRangeA: ('FloatPin', 0.0) = ('FloatPin', 0.0), OutRangeB: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Returns Value mapped from one range into another where the Value is clamped to the Input Range. (e.g. 0.5 normalized from the range 0->1 to 0->50 would result in 25)

static modulo(a: ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}) = ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}), b: ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}) = ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']})) -> ('AnyPin', None, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']})

Modulo (A % B).

static multiply(a: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), b: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'})) -> ('AnyPin', None, {'constraint': '1'})

Operator *.

static subtract(a: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'}), b: ('AnyPin', None, {'constraint': '1'}) = ('AnyPin', None, {'constraint': '1'})) -> ('AnyPin', None, {'constraint': '1'})

Operator -.

PyFlow.Packages.PyFlowBase.FunctionLibraries.MathLib module

class PyFlow.Packages.PyFlowBase.FunctionLibraries.MathLib.MathLib(packageName)

Bases: PyFlow.Core.FunctionLibrary.FunctionLibraryBase

Python builtin math module wrapper

__init__(packageName)

Initialize self. See help(type(self)) for accurate signature.

static acos(rad: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return the arc cosine of x, in radians.

static acosh(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), Result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('FloatPin', 0.0)

Return the inverse hyperbolic cosine of x.

static asin(rad: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return the arc sine of x, in radians.

static asinh(x: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return the inverse hyperbolic sine of x.

static atan(rad: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return the arc tangent of x, in radians.

static atan2(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), y: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return atan(a / b), in radians. The result is between -pi and pi. The vector in the plane from the origin to point (x, y) makes this angle with the positive X axis. The point of atan2() is that the signs of both inputs are known to it, so it can compute the correct quadrant for the angle. For example, atan(1) and atan2(1, 1) are both pi/4, but atan2(-1, -1) is -3*pi/4.

static atanh(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), Result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('FloatPin', 0.0)

Return the inverse hyperbolic tangent of x.

static ceil(x: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return the ceiling of x as a float, the smallest integer value greater than or equal to x.

static copysign(x: ('AnyPin', 0, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}) = ('AnyPin', 0, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}), y: ('AnyPin', 0, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}) = ('AnyPin', 0, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']})) -> ('AnyPin', 0, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']})

Return x with the sign of y. On a platform that supports signed zeros, copysign(1.0, -0.0) returns -1.0.

static cos(rad: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return the cosine of x radians.

static cosh(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), Result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('FloatPin', 0.0)

Return the hyperbolic cosine of x.

static degtorad(deg: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Convert angle x from degrees to radians.

static e() -> ('FloatPin', 0.0)

The mathematical constant e = 2.718281, to available precision.

static erf(x: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return the error function at x.

static erfc(x: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return the complementary error function at x.

static exp(x: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return e**x.

static expm1(x: ('FloatPin', 0.1) = ('FloatPin', 0.1)) -> ('FloatPin', 0.0)

Return e**x - 1. For small floats x, the subtraction in exp(x) - 1 can result in a significant loss of precision.

static factorial(x: ('IntPin', 0) = ('IntPin', 0), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('IntPin', 0)

Return x factorial. Raises ValueError if x is not integral or is negative.

static floor(x: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('IntPin', 0)

Return the floor of x as an Integral.

static fmod(x: ('AnyPin', 0, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}) = ('AnyPin', 0, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}), y: ('AnyPin', 0, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']}) = ('AnyPin', 0, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']})) -> ('AnyPin', 0, {'constraint': '1', 'supportedDataTypes': ['FloatPin', 'IntPin']})

Return fmod(x, y), as defined by the platform C library.

static frexp(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), m: ('Reference', ('FloatPin', 0.0)) = ('Reference', ('FloatPin', 0.0)), e: ('Reference', ('IntPin', 0)) = ('Reference', ('IntPin', 0))) → None

Return the mantissa and exponent of x as the pair (m, e). m is x float and e is an integer such that x == m * 2**e exactly.

static fsum(arr: ('FloatPin', []) = ('FloatPin', []), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('FloatPin', 0.0)

Return an accurate floating point sum of values in the iterable. Avoids loss of precision by tracking multiple intermediate partial sums.

static gamma(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), Result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('FloatPin', 0.0)

Return the Gamma function at x.

static hypot(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), y: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return the Euclidean norm, sqrt(x*x + y*y). This is the length of the vector from the origin to point (x, y).

static isinf(x: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('BoolPin', False)

Check if the float x is positive or negative infinity.

static isnan(x: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('BoolPin', False)

Check if the float x is a NaN (not a number).

static ldexp(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), i: ('IntPin', 0) = ('IntPin', 0)) -> ('FloatPin', 0.0)

Return x * (2**i). This is essentially the inverse of function frexp().

static lgamma(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), Result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('FloatPin', 0.0)

Return the natural logarithm of the absolute value of the Gamma function at x.

static log(x: ('FloatPin', 1.0) = ('FloatPin', 1.0), base: ('FloatPin', 2.718281828459045) = ('FloatPin', 2.718281828459045), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('FloatPin', 0.0)

Return the logarithm of x to the given base, calculated as log(x)/log(base).

static log10(x: ('FloatPin', 1.0) = ('FloatPin', 1.0), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('FloatPin', 0.0)

Return the base-10 logarithm of x. This is usually more accurate than log(x, 10).

static log1p(x: ('FloatPin', 1.0) = ('FloatPin', 1.0), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('FloatPin', 0.0)

Return the natural logarithm of 1+x (base e). The result is calculated in a way which is accurate for x near zero.

static modf(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), f: ('Reference', ('FloatPin', 0.0)) = ('Reference', ('FloatPin', 0.0)), i: ('Reference', ('FloatPin', 0.0)) = ('Reference', ('FloatPin', 0.0))) → None

Return the fractional and integer parts of x. Both results carry the sign of x and are floats.

static pi() -> ('FloatPin', 0.0)

The mathematical constant = 3.141592, to available precision.

static power(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), y: ('FloatPin', 0.0) = ('FloatPin', 0.0), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('FloatPin', 0.0)

Return x raised to the power y.

static radtodeg(rad: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Convert angle x from radians to degrees.

static sin(rad: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return the sine of x radians.

static sinh(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), Result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('FloatPin', 0.0)

Return the hyperbolic sine of x.

static sqrt(x: ('FloatPin', 0.0) = ('FloatPin', 0.0), result: ('Reference', ('BoolPin', False)) = ('Reference', ('BoolPin', False))) -> ('FloatPin', 0.0)

Return the square root of x.

static tan(rad: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return the tangent of x radians.

static tanh(x: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('FloatPin', 0.0)

Return the hyperbolic tangent of x.

static trunc(x: ('FloatPin', 0.0) = ('FloatPin', 0.0)) -> ('IntPin', 0)

Return the Real value x truncated to an Integral (usually a long integer).

PyFlow.Packages.PyFlowBase.FunctionLibraries.PathLib module

class PyFlow.Packages.PyFlowBase.FunctionLibraries.PathLib.PathLib(packageName)

Bases: PyFlow.Core.FunctionLibrary.FunctionLibraryBase

Os.Path Library wrap

__init__(packageName)

Initialize self. See help(type(self)) for accurate signature.

static abspath(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('StringPin', '')

Return a absolute version of a path. On most platforms, this is equivalent to calling the function normpath()

static basename(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('StringPin', '')

Return the base name of pathname path. This is the second element of the pair returned by passing path to the function split(). Note that the result of this function is different from the Unix basename program; where basename for ‘/foo/bar/’ returns ‘bar’, the basename() function returns an empty string (‘’)

static commonprefix(path: ('StringPin', []) = ('StringPin', [])) -> ('StringPin', '')

Return the longest path prefix (taken character-by-character) that is a prefix of all paths in list. If list is empty, return the empty string (‘’). Note that this may return invalid paths because it works a character at a time

static dirname(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('StringPin', '')

Return the directory name of pathname path. This is the first element of the pair returned by passing path to the function split().

static exists(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('BoolPin', False)

Return True if path refers to an existing path. Returns False for broken symbolic links. On some platforms, this function may return False if permission is not granted to execute os.stat() on the requested file, even if the path physically exists.

static expanduser(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('StringPin', '')

On Unix and Windows, return the argument with an initial component of ~ or ~user replaced by that user’s home directory. On Unix, an initial ~ is replaced by the environment variable HOME if it is set; otherwise the current user’s home directory is looked up in the password directory through the built-in module pwd. An initial ~user is looked up directly in the password directory. On Windows, HOME and USERPROFILE will be used if set, otherwise a combination of HOMEPATH and HOMEDRIVE will be used. An initial ~user is handled by stripping the last directory component from the created user path derived above. If the expansion fails or if the path does not begin with a tilde, the path is returned unchanged.

static expandvars(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('StringPin', '')

Return the argument with environment variables expanded. Substrings of the form $name or ${name} are replaced by the value of environment variable name. Malformed variable names and references to non-existing variables are left unchanged. On Windows, %name% expansions are supported in addition to $name and ${name}.

static getFiles(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('StringPin'[])

Lists files on Path

static getFolders(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('StringPin'[])

Lists directories on Path

static getatime(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('FloatPin', 0.0)

Return the time of last access of path. The return value is a number giving the number of seconds since the epoch (see the time module). Raise os.error if the file does not exist or is inaccessible.

static getctime(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('FloatPin', 0.0)

Return the system’s ctime which, on some systems (like Unix) is the time of the last metadata change, and, on others (like Windows), is the creation time for path. The return value is a number giving the number of seconds since the epoch (see the time module). Raise os.error if the file does not exist or is inaccessible.

static getmtime(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('FloatPin', 0.0)

Return the time of last modification of path. The return value is a number giving the number of seconds since the epoch (see the time module). Raise os.error if the file does not exist or is inaccessible.

static getsize(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('IntPin', 0)

Return the size, in bytes, of path. Raise os.error if the file does not exist or is inaccessible.

static isDir(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('BoolPin', False)

Return True if path is an existing directory. This follows symbolic links, so both islink() and isdir() can be true for the same path.

static isFile(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('BoolPin', False)

Return True if path is an existing regular file. This follows symbolic links, so both islink() and isfile() can be true for the same path.

static isabs(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('BoolPin', False)

Return True if path is an absolute pathname. On Unix, that means it begins with a slash, on Windows that it begins with a (back)slash after chopping off a potential drive letter.

Return True if path refers to a directory entry that is a symbolic link. Always False if symbolic links are not supported by the Python runtime.

static ismount(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('BoolPin', False)

Return True if pathname path is a mount point: a point in a file system where a different file system has been mounted. The function checks whether path’s parent, path/.., is on a different device than path, or whether path/.. and path point to the same i-node on the same device — this should detect mount points for all Unix and POSIX variants.

static join(base: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}), paths: ('StringPin', []) = ('StringPin', [])) -> ('StringPin', '')
Join one or more path components intelligently. The return value is the concatenation of path and any members of *paths with exactly one directory separator (os.sep) following each non-empty part except the last, meaning that the result will only end in a separator if the last part is empty. If a component is an absolute path, all previous components are thrown away and joining continues from the absolute path component.
On Windows, the drive letter is not reset when an absolute path component (e.g., r’

oo’) is encountered. If a component contains a drive letter, all previous components are thrown away and the drive letter is reset. Note that since there is a current directory for each drive, os.path.join(“c:”, “foo”) represents a path relative to the current directory on drive C: (c:foo), not c: oo.

static lexists(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('BoolPin', False)

Return True if path refers to an existing path. Returns True for broken symbolic links. Equivalent to exists() on platforms lacking os.lstat().

static listDir(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('StringPin'[])

Lists files and directories on Path

static normcase(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('StringPin', '')

Normalize the case of a pathname. On Unix and Mac OS X, this returns the path unchanged; on case-insensitive filesystems, it converts the path to lowercase. On Windows, it also converts forward slashes to backward slashes.

static normpath(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('StringPin', '')

Normalize a pathname by collapsing redundant separators and up-level references so that A//B, A/B/, A/./B and A/foo/../B all become A/B. This string manipulation may change the meaning of a path that contains symbolic links. On Windows, it converts forward slashes to backward slashes. To normalize case, use normcase().

static realpath(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'})) -> ('StringPin', '')

Return the canonical path of the specified filename, eliminating any symbolic links encountered in the path (if they are supported by the operating system).

static relpath(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}), start: ('StringPin', '.') = ('StringPin', '.')) -> ('StringPin', '')

Return a relative filepath to path either from the current directory or from an optional start directory. This is a path computation: the filesystem is not accessed to confirm the existence or nature of path or start. start defaults to os.curdir. Availability: Windows, Unix.

static split(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}), head: ('Reference', ('StringPin', '')) = ('Reference', ('StringPin', '')), tail: ('Reference', ('StringPin', '')) = ('Reference', ('StringPin', ''))) -> ('StringPin'[])

Split the pathname path into a pair, (head, tail) where tail is the last pathname component and head is everything leading up to that. The tail part will never contain a slash; if path ends in a slash, tail will be empty. If there is no slash in path, head will be empty. If path is empty, both head and tail are empty. Trailing slashes are stripped from head unless it is the root (one or more slashes only). In all cases, join(head, tail) returns a path to the same location as path (but the strings may differ). Also see the functions dirname() and basename().

static splitdrive(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}), drive: ('Reference', ('StringPin', '')) = ('Reference', ('StringPin', '')), tail: ('Reference', ('StringPin', '')) = ('Reference', ('StringPin', ''))) -> ('StringPin'[])

Split the pathname path into a pair (drive, tail) where drive is either a drive specification or the empty string. On systems which do not use drive specifications, drive will always be the empty string. In all cases, drive + tail will be the same as path.

static splitext(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}), root: ('Reference', ('StringPin', '')) = ('Reference', ('StringPin', '')), ext: ('Reference', ('StringPin', '')) = ('Reference', ('StringPin', ''))) -> ('StringPin'[])

Split the pathname path into a pair (root, ext) such that root + ext == path, and ext is empty or begins with a period and contains at most one period. Leading periods on the basename are ignored; splitext(‘.cshrc’) returns (‘.cshrc’, ‘’).

static splitunc(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}), unc: ('Reference', ('StringPin', '')) = ('Reference', ('StringPin', '')), rest: ('Reference', ('StringPin', '')) = ('Reference', ('StringPin', ''))) -> ('StringPin'[])

Split the pathname path into a pair (unc, rest) so that unc is the UNC mount point (such as r’hostmount’), if present, and rest the rest of the path (such as r’path ile.ext’). For paths containing drive letters, unc will always be the empty string.

static walk(path: ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}) = ('StringPin', '', {'inputWidgetVariant': 'PathWidget'}), topdown: ('BoolPin', False) = ('BoolPin', False), files: ('Reference', ('StringPin', [])) = ('Reference', ('StringPin', [])), folders: ('Reference', ('StringPin', [])) = ('Reference', ('StringPin', []))) -> ('StringPin'[])

Lists files and directories on Path recursive

PyFlow.Packages.PyFlowBase.FunctionLibraries.RandomLib module

class PyFlow.Packages.PyFlowBase.FunctionLibraries.RandomLib.RandomLib(packageName)

Bases: PyFlow.Core.FunctionLibrary.FunctionLibraryBase

doc string for RandomLib

__init__(packageName)

Initialize self. See help(type(self)) for accurate signature.

static randint(start: ('IntPin', 0) = ('IntPin', 0), end: ('IntPin', 10) = ('IntPin', 10), Result: ('Reference', ('IntPin', 0)) = ('Reference', ('IntPin', 0))) → None

Return a random integer N such that a <= N <= b.

static shuffle(seq: ('AnyPin', []{'constraint': '1'}) = ('AnyPin', []{'constraint': '1'}), Result: ('Reference', ('AnyPin', []{'constraint': '1'})) = ('Reference', ('AnyPin', []{'constraint': '1'}))) → None

Shuffle the sequence x in place.

Module contents