code0-hercules 1.3.0__py3-none-any.whl

hercules/definitions/taurus_boolean/runtime_functions/std_boolean_as_number.py

@@ -0,0 +1,18 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::boolean::as_number")
+@Signature("(value: BOOLEAN): NUMBER")
+@Name({"code": "en-US", "content": "Boolean as Number"})
+@Description({"code": "en-US", "content": "Will convert the boolean to a number."})
+@DisplayMessage({"code": "en-US", "content": "Convert ${value} to number"})
+@Alias({"code": "en-US", "content": "to number;numeric;boolean;logic;std;as;number"})
+@DisplayIcon("tabler:toggle-left")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "Converts a boolean to a number."}]})
+class StdBooleanAsNumber(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdBooleanAsNumber.run() is not implemented")

hercules/definitions/taurus_boolean/runtime_functions/std_boolean_as_text.py

@@ -0,0 +1,18 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::boolean::as_text")
+@Signature("(value: BOOLEAN): TEXT")
+@Name({"code": "en-US", "content": "Boolean as Text"})
+@Description({"code": "en-US", "content": "Will convert the boolean to text."})
+@DisplayMessage({"code": "en-US", "content": "Convert ${value} to text"})
+@Alias({"code": "en-US", "content": "to text;string;format number;boolean;logic;std;as;text"})
+@DisplayIcon("tabler:toggle-left")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "Converts a boolean to a text."}]})
+class StdBooleanAsText(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdBooleanAsText.run() is not implemented")

hercules/definitions/taurus_boolean/runtime_functions/std_boolean_from_number.py

@@ -0,0 +1,18 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::boolean::from_number")
+@Signature("(value: NUMBER): BOOLEAN")
+@Name({"code": "en-US", "content": "Boolean from Number"})
+@Description({"code": "en-US", "content": "Will convert the number to a boolean."})
+@DisplayMessage({"code": "en-US", "content": "Convert ${value} to boolean"})
+@Alias({"code": "en-US", "content": "from number;to boolean;convert;boolean;logic;std;from;number"})
+@DisplayIcon("tabler:toggle-left")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "Converts a number to a boolean."}]})
+class StdBooleanFromNumber(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdBooleanFromNumber.run() is not implemented")

hercules/definitions/taurus_boolean/runtime_functions/std_boolean_from_text.py

@@ -0,0 +1,18 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::boolean::from_text")
+@Signature("(value: TEXT): BOOLEAN")
+@Name({"code": "en-US", "content": "Boolean from Text"})
+@Description({"code": "en-US", "content": "Will convert the string to a boolean."})
+@DisplayMessage({"code": "en-US", "content": "Convert ${value} to boolean"})
+@Alias({"code": "en-US", "content": "from text;parse;convert;boolean;logic;std;from;text"})
+@DisplayIcon("tabler:toggle-left")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "Converts a text to a boolean."}]})
+class StdBooleanFromText(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdBooleanFromText.run() is not implemented")

hercules/definitions/taurus_boolean/runtime_functions/std_boolean_is_equal.py

@@ -0,0 +1,19 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::boolean::is_equal")
+@Signature("(first: BOOLEAN, second: BOOLEAN): BOOLEAN")
+@Name({"code": "en-US", "content": "Is Equal"})
+@Description({"code": "en-US", "content": "Compares two boolean values for equality. Returns true if they are the same, false otherwise."})
+@DisplayMessage({"code": "en-US", "content": "${first} Equals ${second}"})
+@Alias({"code": "en-US", "content": "equal;equals;same;boolean;logic;std;is"})
+@DisplayIcon("tabler:toggle-left")
+@Parameter({"runtime_name": "first", "name": [{"code": "en-US", "content": "First"}], "description": [{"code": "en-US", "content": "The first boolean value to compare."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Second"}], "description": [{"code": "en-US", "content": "The second boolean value to compare."}]})
+class StdBooleanIsEqual(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdBooleanIsEqual.run() is not implemented")

hercules/definitions/taurus_boolean/runtime_functions/std_boolean_negate.py

@@ -0,0 +1,18 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::boolean::negate")
+@Signature("(value: BOOLEAN): BOOLEAN")
+@Name({"code": "en-US", "content": "Negate Boolean"})
+@Description({"code": "en-US", "content": "Negates a boolean value."})
+@DisplayMessage({"code": "en-US", "content": "Negate ${value}"})
+@Alias({"code": "en-US", "content": "negate;negative;invert;opposite;boolean;logic;std"})
+@DisplayIcon("tabler:toggle-left")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The boolean value to negate."}]})
+class StdBooleanNegate(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdBooleanNegate.run() is not implemented")

hercules/definitions/taurus_color/data_types/color.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Color(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    hue: float
+    saturation: float
+    lightness: float
+    alpha: float | None = None
+
+
+from hercules.internal.schema import register_schema
+register_schema(Color, "COLOR")

hercules/definitions/taurus_color/runtime_functions/std_color_as_hex.py

@@ -0,0 +1,18 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::color::as_hex")
+@Signature("(value: COLOR): TEXT")
+@Name({"code": "en-US", "content": "Color as Hex"})
+@Description({"code": "en-US", "content": "Formats a color as a `#RRGGBB` hex string, or `#RRGGBBAA` when alpha is not fully opaque."})
+@DisplayMessage({"code": "en-US", "content": "Hex of ${value}"})
+@Alias({"code": "en-US", "content": "to hex;format;convert;color;colour;std;as"})
+@DisplayIcon("tabler:palette")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The color to format as hex."}]})
+class StdColorAsHex(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdColorAsHex.run() is not implemented")

hercules/definitions/taurus_color/runtime_functions/std_color_as_hsl.py

@@ -0,0 +1,18 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::color::as_hsl")
+@Signature("(value: COLOR): { hue: number; saturation: number; lightness: number; alpha: number }")
+@Name({"code": "en-US", "content": "Color as HSL"})
+@Description({"code": "en-US", "content": "Converts a color to its hue (0-360), saturation and lightness (0-100) and alpha (0-1) channels."})
+@DisplayMessage({"code": "en-US", "content": "HSL of ${value}"})
+@Alias({"code": "en-US", "content": "to hsl;convert;color;colour;std;as"})
+@DisplayIcon("tabler:palette")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The color to convert to HSL."}]})
+class StdColorAsHsl(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdColorAsHsl.run() is not implemented")

hercules/definitions/taurus_color/runtime_functions/std_color_as_rgb.py

@@ -0,0 +1,18 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::color::as_rgb")
+@Signature("(value: COLOR): { red: number; green: number; blue: number; alpha: number }")
+@Name({"code": "en-US", "content": "Color as RGB"})
+@Description({"code": "en-US", "content": "Converts a color to its red, green, blue (0-255) and alpha (0-1) channels."})
+@DisplayMessage({"code": "en-US", "content": "RGB of ${value}"})
+@Alias({"code": "en-US", "content": "to rgb;convert;color;colour;std;as"})
+@DisplayIcon("tabler:palette")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The color to convert to RGB."}]})
+class StdColorAsRgb(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdColorAsRgb.run() is not implemented")

hercules/definitions/taurus_color/runtime_functions/std_color_from_hex.py

@@ -0,0 +1,18 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::color::from_hex")
+@Signature("(value: TEXT): COLOR")
+@Name({"code": "en-US", "content": "Color from Hex"})
+@Description({"code": "en-US", "content": "Parses a `#RRGGBB` or `#RRGGBBAA` hex string into a color."})
+@DisplayMessage({"code": "en-US", "content": "Color from ${value}"})
+@Alias({"code": "en-US", "content": "from hex;parse;convert;color;colour;std;from"})
+@DisplayIcon("tabler:palette")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The hex text to parse, e.g. `#FF00FF` or `#FF00FFAA`."}]})
+class StdColorFromHex(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdColorFromHex.run() is not implemented")

hercules/definitions/taurus_color/runtime_functions/std_color_from_hsl.py

@@ -0,0 +1,21 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::color::from_hsl")
+@Signature("(hue: NUMBER, saturation: NUMBER, lightness: NUMBER, alpha?: NUMBER): COLOR")
+@Name({"code": "en-US", "content": "Color from HSL"})
+@Description({"code": "en-US", "content": "Builds a color from hue (0-360), saturation and lightness (0-100) and an alpha channel (0-1)."})
+@DisplayMessage({"code": "en-US", "content": "Color from ${hue}, ${saturation}, ${lightness}, ${alpha}"})
+@Alias({"code": "en-US", "content": "from hsl;build;convert;color;colour;std;from"})
+@DisplayIcon("tabler:palette")
+@Parameter({"runtime_name": "hue", "name": [{"code": "en-US", "content": "Hue"}], "description": [{"code": "en-US", "content": "The hue, from 0 to 360."}]})
+@Parameter({"runtime_name": "saturation", "name": [{"code": "en-US", "content": "Saturation"}], "description": [{"code": "en-US", "content": "The saturation, from 0 to 100."}]})
+@Parameter({"runtime_name": "lightness", "name": [{"code": "en-US", "content": "Lightness"}], "description": [{"code": "en-US", "content": "The lightness, from 0 to 100."}]})
+@Parameter({"runtime_name": "alpha", "name": [{"code": "en-US", "content": "Alpha"}], "description": [{"code": "en-US", "content": "The opacity, from 0 to 1. Defaults to 1 (fully opaque) when omitted."}]})
+class StdColorFromHsl(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdColorFromHsl.run() is not implemented")

hercules/definitions/taurus_color/runtime_functions/std_color_from_rgb.py

@@ -0,0 +1,21 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::color::from_rgb")
+@Signature("(red: NUMBER, green: NUMBER, blue: NUMBER, alpha?: NUMBER): COLOR")
+@Name({"code": "en-US", "content": "Color from RGB"})
+@Description({"code": "en-US", "content": "Builds a color from red, green and blue channels (0-255) and an alpha channel (0-1)."})
+@DisplayMessage({"code": "en-US", "content": "Color from ${red}, ${green}, ${blue}, ${alpha}"})
+@Alias({"code": "en-US", "content": "from rgb;build;convert;color;colour;std;from"})
+@DisplayIcon("tabler:palette")
+@Parameter({"runtime_name": "red", "name": [{"code": "en-US", "content": "Red"}], "description": [{"code": "en-US", "content": "The red channel, from 0 to 255."}]})
+@Parameter({"runtime_name": "green", "name": [{"code": "en-US", "content": "Green"}], "description": [{"code": "en-US", "content": "The green channel, from 0 to 255."}]})
+@Parameter({"runtime_name": "blue", "name": [{"code": "en-US", "content": "Blue"}], "description": [{"code": "en-US", "content": "The blue channel, from 0 to 255."}]})
+@Parameter({"runtime_name": "alpha", "name": [{"code": "en-US", "content": "Alpha"}], "description": [{"code": "en-US", "content": "The opacity, from 0 to 1. Defaults to 1 (fully opaque) when omitted."}]})
+class StdColorFromRgb(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdColorFromRgb.run() is not implemented")

hercules/definitions/taurus_control/data_types/comparator.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class NamedArgs(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    left: Any
+    right: Any
+
+
+class Comparator(BaseModel):
+    namedArgs: NamedArgs | None = None
+
+
+from hercules.internal.schema import register_schema
+register_schema(Comparator, "COMPARATOR")

hercules/definitions/taurus_control/data_types/consumer.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class NamedArgs(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    item: Any
+
+
+class Consumer(BaseModel):
+    namedArgs: NamedArgs | None = None
+
+
+from hercules.internal.schema import register_schema
+register_schema(Consumer, "CONSUMER")

hercules/definitions/taurus_control/data_types/predicate.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class NamedArgs(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    item: Any
+
+
+class Predicate(BaseModel):
+    namedArgs: NamedArgs | None = None
+
+
+from hercules.internal.schema import register_schema
+register_schema(Predicate, "PREDICATE")

hercules/definitions/taurus_control/data_types/runnable.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import RootModel
+
+
+class Runnable(RootModel[Any]):
+    root: Any
+
+
+from hercules.internal.schema import register_schema
+register_schema(Runnable, "RUNNABLE")

hercules/definitions/taurus_control/data_types/transform.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class NamedArgs(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    item: Any
+
+
+class Transform(BaseModel):
+    namedArgs: NamedArgs | None = None
+
+
+from hercules.internal.schema import register_schema
+register_schema(Transform, "TRANSFORM")

hercules/definitions/taurus_control/runtime_functions/std_control_if.py

@@ -0,0 +1,19 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::control::if")
+@Signature("(condition: BOOLEAN, runnable: RUNNABLE): void")
+@Name({"code": "en-US", "content": "If"})
+@Description({"code": "en-US", "content": "The 'If' runnable evaluates a boolean condition and, if it is true, executes the provided runnable. If the condition is false, execution continues without running the runnable."})
+@DisplayMessage({"code": "en-US", "content": "If ${condition} is True do ${runnable}"})
+@Alias({"code": "en-US", "content": "if;control;std"})
+@DisplayIcon("tabler:arrow-ramp-right-2")
+@Parameter({"runtime_name": "condition", "name": [{"code": "en-US", "content": "Condition"}], "description": [{"code": "en-US", "content": "Specifies the condition that determines whether the provided runnable should be executed. If this condition evaluates to true, the execution proceeds with the runnable defined in the second parameter."}]})
+@Parameter({"runtime_name": "runnable", "name": [{"code": "en-US", "content": "Runnable"}], "description": [{"code": "en-US", "content": "Defines the runnable that runs if the condition evaluates to true."}]})
+class StdControlIf(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdControlIf.run() is not implemented")

hercules/definitions/taurus_control/runtime_functions/std_control_if_else.py

@@ -0,0 +1,21 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Documentation, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::control::if_else")
+@Signature("(condition: BOOLEAN, runnable: RUNNABLE, else_runnable: RUNNABLE): void")
+@Name({"code": "en-US", "content": "If-Else"})
+@Description({"code": "en-US", "content": "Evaluates a condition and executes either the Then Runnable or the Else Runnable."})
+@Documentation({"code": "en-US", "content": "Evaluates a boolean condition. If true, executes the Runnable. Otherwise executes the Else Runnable."})
+@DisplayMessage({"code": "en-US", "content": "If ${condition} is True do ${then_runnable} else ${else_runnable}"})
+@Alias({"code": "en-US", "content": "if_else;control;std;if;else"})
+@DisplayIcon("tabler:arrow-ramp-right")
+@Parameter({"runtime_name": "condition", "name": [{"code": "en-US", "content": "Condition"}], "description": [{"code": "en-US", "content": "Boolean that determines which branch to execute. If true the Runnable runs otherwise the Else Runnable runs."}]})
+@Parameter({"runtime_name": "runnable", "name": [{"code": "en-US", "content": "Runnable"}], "description": [{"code": "en-US", "content": "Defines the runnable that runs if the condition evaluates to true."}]})
+@Parameter({"runtime_name": "else_runnable", "name": [{"code": "en-US", "content": "Else Runnable"}], "description": [{"code": "en-US", "content": "Defines the runnable that runs if the condition evaluates to false."}]})
+class StdControlIfElse(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdControlIfElse.run() is not implemented")

hercules/definitions/taurus_control/runtime_functions/std_control_return.py

@@ -0,0 +1,18 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::control::return")
+@Signature("<T>(value: T): T")
+@Name({"code": "en-US", "content": "Return"})
+@Description({"code": "en-US", "content": "Ends the current context and returns the specified value to the upper scope."})
+@DisplayMessage({"code": "en-US", "content": "Return ${value}"})
+@Alias({"code": "en-US", "content": "return;control;std"})
+@DisplayIcon("tabler:arrow-back")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Return Value"}], "description": [{"code": "en-US", "content": "The value to be returned to the upper context."}]})
+class StdControlReturn(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdControlReturn.run() is not implemented")

hercules/definitions/taurus_control/runtime_functions/std_control_stop.py

@@ -0,0 +1,16 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+
+
+@OmitRuntimeFunction()
+@Identifier("std::control::stop")
+@Signature("(): void")
+@Name({"code": "en-US", "content": "Stop"})
+@Description({"code": "en-US", "content": "Terminates the current execution context entirely, halting all ongoing and future iterations. Once invoked, no additional steps or loops within this context will be executed. This node behaves like a global stop or termination signal within the flow."})
+@DisplayMessage({"code": "en-US", "content": "Stop"})
+@Alias({"code": "en-US", "content": "stop;control;std"})
+@DisplayIcon("tabler:xbox-x")
+class StdControlStop(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdControlStop.run() is not implemented")

hercules/definitions/taurus_control/runtime_functions/std_control_value.py

@@ -0,0 +1,18 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::control::value")
+@Signature("<T>(value: T): T")
+@Name({"code": "en-US", "content": "Set Value"})
+@Description({"code": "en-US", "content": "Saves the given value."})
+@DisplayMessage({"code": "en-US", "content": "Save ${value}"})
+@Alias({"code": "en-US", "content": "value;save;create;control;std"})
+@DisplayIcon("tabler:new-section")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The value to save."}]})
+class StdControlValue(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdControlValue.run() is not implemented")

hercules/definitions/taurus_date/data_types/date.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from pydantic import RootModel
+
+
+class Date(RootModel[float]):
+    root: float
+
+
+from hercules.internal.schema import register_schema
+register_schema(Date, "DATE")

hercules/definitions/taurus_date/data_types/hour.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from pydantic import RootModel
+
+
+class Hour(RootModel[float]):
+    root: float
+
+
+from hercules.internal.schema import register_schema
+register_schema(Hour, "HOUR")

hercules/definitions/taurus_date/data_types/minute.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from pydantic import RootModel
+
+
+class Minute(RootModel[float]):
+    root: float
+
+
+from hercules.internal.schema import register_schema
+register_schema(Minute, "MINUTE")

hercules/definitions/taurus_date/data_types/month.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class Month(Enum):
+    JAN = 'JAN'
+    FEB = 'FEB'
+    MAR = 'MAR'
+    APR = 'APR'
+    MAY = 'MAY'
+    JUN = 'JUN'
+    JUL = 'JUL'
+    AUG = 'AUG'
+    SEP = 'SEP'
+    OCT = 'OCT'
+    NOV = 'NOV'
+    DEC = 'DEC'
+
+
+from hercules.internal.schema import register_schema
+register_schema(Month, "MONTH")

hercules/definitions/taurus_date/runtime_functions/std_date_format.py

@@ -0,0 +1,20 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import ThrowsError, Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::date::format")
+@Signature("(date: DATE, pattern: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Format Date"})
+@Description({"code": "en-US", "content": "Converts a date into a formatted text using the given pattern. Throws an error if the pattern is invalid."})
+@DisplayMessage({"code": "en-US", "content": "Format ${date} as ${pattern}"})
+@Alias({"code": "en-US", "content": "format;pattern;stringify;to text;display;date;time;std"})
+@DisplayIcon("tabler:calendar-cog")
+@ThrowsError()
+@Parameter({"runtime_name": "date", "name": [{"code": "en-US", "content": "Date"}], "description": [{"code": "en-US", "content": "The date that will be formatted."}]})
+@Parameter({"runtime_name": "pattern", "name": [{"code": "en-US", "content": "Pattern"}], "description": [{"code": "en-US", "content": "The pattern used to format the date, for example DD:MM:YYYY or YY:MM:DD."}]})
+class StdDateFormat(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdDateFormat.run() is not implemented")

hercules/definitions/taurus_date/runtime_functions/std_date_from.py

@@ -0,0 +1,24 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import ThrowsError, Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::date::from")
+@Signature("(year: NUMBER, month: MONTH, day: NUMBER, hour: HOUR, minute: MINUTE, second: NUMBER): DATE")
+@Name({"code": "en-US", "content": "Date from Components"})
+@Description({"code": "en-US", "content": "Creates a date from the given year, month, day, hour, minute and second. Throws an error if the combination does not represent a valid date."})
+@DisplayMessage({"code": "en-US", "content": "Date ${day} ${month} ${year} at ${hour}:${minute}:${second}"})
+@Alias({"code": "en-US", "content": "from;create;build;construct;date;year;month;day;time;std"})
+@DisplayIcon("tabler:calendar-plus")
+@ThrowsError()
+@Parameter({"runtime_name": "year", "name": [{"code": "en-US", "content": "Year"}], "description": [{"code": "en-US", "content": "The year of the date, for example 2026."}]})
+@Parameter({"runtime_name": "month", "name": [{"code": "en-US", "content": "Month"}], "description": [{"code": "en-US", "content": "The month of the date."}]})
+@Parameter({"runtime_name": "day", "name": [{"code": "en-US", "content": "Day"}], "description": [{"code": "en-US", "content": "The day of the month, ranging from 1 to 31."}]})
+@Parameter({"runtime_name": "hour", "name": [{"code": "en-US", "content": "Hour"}], "description": [{"code": "en-US", "content": "The hour of the day, ranging from 0 to 23."}]})
+@Parameter({"runtime_name": "minute", "name": [{"code": "en-US", "content": "Minute"}], "description": [{"code": "en-US", "content": "The minute of the hour, ranging from 0 to 59."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Second"}], "description": [{"code": "en-US", "content": "The second of the minute, ranging from 0 to 59."}]})
+class StdDateFrom(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdDateFrom.run() is not implemented")

hercules/definitions/taurus_date/runtime_functions/std_date_from_text.py

@@ -0,0 +1,19 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import ThrowsError, Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::date::from_text")
+@Signature("(value: TEXT): DATE")
+@Name({"code": "en-US", "content": "Date from Text"})
+@Description({"code": "en-US", "content": "Parses a date from its textual representation. Throws an error if the text cannot be parsed into a valid date."})
+@DisplayMessage({"code": "en-US", "content": "Date from text ${value}"})
+@Alias({"code": "en-US", "content": "from text;parse;string;iso;from;date;time;std"})
+@DisplayIcon("tabler:calendar-plus")
+@ThrowsError()
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The textual representation of the date, for example an ISO 8601 string like 2026-07-28T10:15:30Z."}]})
+class StdDateFromText(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdDateFromText.run() is not implemented")