code0-hercules 1.3.0__py3-none-any.whl

hercules/definitions/taurus_list/runtime_functions/std_list_max.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::list::max")
+@Signature("(list: LIST<NUMBER>): NUMBER")
+@Name({"code": "en-US", "content": "Find Maximum Number"})
+@Description({"code": "en-US", "content": "Finds the maximum value in a numeric list."})
+@DisplayMessage({"code": "en-US", "content": "Maximum of ${list}"})
+@Alias({"code": "en-US", "content": "max;maximum;largest;greatest;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "List of Numbers"}], "description": [{"code": "en-US", "content": "A list of numbers to find the maximum value from."}]})
+class StdListMax(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListMax.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_min.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::list::min")
+@Signature("(list: LIST<NUMBER>): NUMBER")
+@Name({"code": "en-US", "content": "Find Minimum Number"})
+@Description({"code": "en-US", "content": "Finds the minimum value in a numeric list."})
+@DisplayMessage({"code": "en-US", "content": "Minimum of ${list}"})
+@Alias({"code": "en-US", "content": "min;minimum;smallest;least;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "Number List"}], "description": [{"code": "en-US", "content": "A list of numbers to find the minimum value from."}]})
+class StdListMin(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListMin.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_pop.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::list::pop")
+@Signature("<T>(list: LIST<T>): T")
+@Name({"code": "en-US", "content": "Pop from List"})
+@Description({"code": "en-US", "content": "Removes the last element from the specified list and returns it. The list will be modified."})
+@DisplayMessage({"code": "en-US", "content": "Remove Last Item of ${list}"})
+@Alias({"code": "en-US", "content": "pop;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "List"}], "description": [{"code": "en-US", "content": "The list to remove the last item from."}]})
+class StdListPop(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListPop.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_push.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::list::push")
+@Signature("<T>(list: LIST<T>, item: T): NUMBER")
+@Name({"code": "en-US", "content": "Push to List"})
+@Description({"code": "en-US", "content": "Adds a new element to the end of the list and returns the new length of the list."})
+@DisplayMessage({"code": "en-US", "content": "Push ${item} into ${list}"})
+@Alias({"code": "en-US", "content": "push;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "List"}], "description": [{"code": "en-US", "content": "The list to which an item will be added."}]})
+@Parameter({"runtime_name": "item", "name": [{"code": "en-US", "content": "Item"}], "description": [{"code": "en-US", "content": "The value to be added at the end of the list."}]})
+class StdListPush(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListPush.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_remove.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::list::remove")
+@Signature("<T>(list: LIST<T>, item: T): LIST<T>")
+@Name({"code": "en-US", "content": "Remove from List"})
+@Description({"code": "en-US", "content": "Removes the first matching item from the given list and returns the resulting list."})
+@DisplayMessage({"code": "en-US", "content": "Remove ${item} from ${list}"})
+@Alias({"code": "en-US", "content": "remove;delete;strip;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "List"}], "description": [{"code": "en-US", "content": "The list from which the item will be removed."}]})
+@Parameter({"runtime_name": "item", "name": [{"code": "en-US", "content": "Item"}], "description": [{"code": "en-US", "content": "The item to remove from the list."}]})
+class StdListRemove(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListRemove.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_reverse.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::list::reverse")
+@Signature("<T>(list: LIST<T>): LIST<T>")
+@Name({"code": "en-US", "content": "Reverse List"})
+@Description({"code": "en-US", "content": "Returns a new list with the elements of the input list in reverse order."})
+@DisplayMessage({"code": "en-US", "content": "Reverse ${list}"})
+@Alias({"code": "en-US", "content": "reverse;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "List"}], "description": [{"code": "en-US", "content": "The input list to be reversed."}]})
+class StdListReverse(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListReverse.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_size.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::list::size")
+@Signature("<T>(list: LIST<T>): NUMBER")
+@Name({"code": "en-US", "content": "List Size"})
+@Description({"code": "en-US", "content": "This function returns the count of elements present in the given list."})
+@DisplayMessage({"code": "en-US", "content": "Size of ${list}"})
+@Alias({"code": "en-US", "content": "size;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "List"}], "description": [{"code": "en-US", "content": "The list whose number of elements is to be returned."}]})
+class StdListSize(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListSize.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_sort.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::list::sort")
+@Signature("<T>(list: LIST<T>, comparator: COMPARATOR<T>): LIST<T>")
+@Name({"code": "en-US", "content": "Sort List"})
+@Description({"code": "en-US", "content": "Returns a new list with the elements sorted according to the comparator function provided."})
+@DisplayMessage({"code": "en-US", "content": "Sort ${list} using ${comparator}"})
+@Alias({"code": "en-US", "content": "sort;array;list;collection;std"})
+@DisplayIcon("tabler:arrow-iteration")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "List"}], "description": [{"code": "en-US", "content": "The input list to be sorted."}]})
+@Parameter({"runtime_name": "comparator", "name": [{"code": "en-US", "content": "Comparator"}], "description": [{"code": "en-US", "content": "A function that takes two elements and returns a negative, zero, or positive number to indicate their ordering."}]})
+class StdListSort(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListSort.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_sort_reverse.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::list::sort_reverse")
+@Signature("<T>(list: LIST<T>, comparator: COMPARATOR<T>): LIST<T>")
+@Name({"code": "en-US", "content": "Sort List in Reverse"})
+@Description({"code": "en-US", "content": "Returns a new list with the elements sorted in descending order according to the comparator function provided."})
+@DisplayMessage({"code": "en-US", "content": "Reversed-Sort ${list} using ${comparator}"})
+@Alias({"code": "en-US", "content": "sort_reverse;array;list;collection;std;sort;reverse"})
+@DisplayIcon("tabler:arrow-iteration")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "List"}], "description": [{"code": "en-US", "content": "The input list to be sorted in reverse order."}]})
+@Parameter({"runtime_name": "comparator", "name": [{"code": "en-US", "content": "Comparator"}], "description": [{"code": "en-US", "content": "A function that takes two elements and returns a negative, zero, or positive number to indicate their ordering."}]})
+class StdListSortReverse(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListSortReverse.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_sum.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::list::sum")
+@Signature("(list: LIST<NUMBER>): NUMBER")
+@Name({"code": "en-US", "content": "Sum of Numbers"})
+@Description({"code": "en-US", "content": "Returns the total sum of the elements in the numeric list."})
+@DisplayMessage({"code": "en-US", "content": "Sum of ${list}"})
+@Alias({"code": "en-US", "content": "sum;total;add all;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "Number List"}], "description": [{"code": "en-US", "content": "Calculates the sum of all numbers in the given list."}]})
+class StdListSum(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListSum.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_to_unique.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::list::to_unique")
+@Signature("<T>(list: LIST<T>): LIST<T>")
+@Name({"code": "en-US", "content": "To Unique"})
+@Description({"code": "en-US", "content": "Returns a new list containing only the unique elements from the input list."})
+@DisplayMessage({"code": "en-US", "content": "Remove duplicates in ${list}"})
+@Alias({"code": "en-US", "content": "to_unique;array;list;collection;std;to;unique"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "List"}], "description": [{"code": "en-US", "content": "The input list from which duplicates will be removed."}]})
+class StdListToUnique(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListToUnique.run() is not implemented")

hercules/definitions/taurus_number/data_types/number.py

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

hercules/definitions/taurus_number/runtime_functions/std_number_abs.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::number::abs")
+@Signature("(value: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Absolute Value"})
+@Description({"code": "en-US", "content": "Removes the sign from the input number, returning its non-negative value."})
+@DisplayMessage({"code": "en-US", "content": "Absolute Value of ${value}"})
+@Alias({"code": "en-US", "content": "absolute;abs;magnitude;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Number Input"}], "description": [{"code": "en-US", "content": "This is the numeric input. The result will be its absolute (non-negative) value."}]})
+class StdNumberAbs(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberAbs.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_add.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::number::add")
+@Signature("(first: NUMBER, second: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Add Numbers"})
+@Description({"code": "en-US", "content": "Adds two numbers together."})
+@DisplayMessage({"code": "en-US", "content": "${first} Plus ${second}"})
+@Alias({"code": "en-US", "content": "add;plus;sum;total;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "first", "name": [{"code": "en-US", "content": "First Number"}], "description": [{"code": "en-US", "content": "The first number to add."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Second Number"}], "description": [{"code": "en-US", "content": "The second number to add."}]})
+class StdNumberAdd(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberAdd.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_arccos.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::number::arccos")
+@Signature("(value: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Arccosine"})
+@Description({"code": "en-US", "content": "Computes the angle in radians whose cosine is the given number."})
+@DisplayMessage({"code": "en-US", "content": "Arccosine of ${value}"})
+@Alias({"code": "en-US", "content": "arccos;acos;inverse cosine;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Input Number"}], "description": [{"code": "en-US", "content": "Calculates the arccosine (inverse cosine) of the input value."}]})
+class StdNumberArccos(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberArccos.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_arcsin.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::number::arcsin")
+@Signature("(value: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Arcsine"})
+@Description({"code": "en-US", "content": "Computes the angle in radians whose sine is the given number."})
+@DisplayMessage({"code": "en-US", "content": "Arcsine of ${value}"})
+@Alias({"code": "en-US", "content": "arcsin;asin;inverse sine;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "Calculates the arcsine (inverse sine) of the input value."}]})
+class StdNumberArcsin(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberArcsin.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_arctan.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::number::arctan")
+@Signature("(value: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Arctangent"})
+@Description({"code": "en-US", "content": "Computes the angle in radians whose tangent is the given number."})
+@DisplayMessage({"code": "en-US", "content": "Arctangent of ${value}"})
+@Alias({"code": "en-US", "content": "arctan;atan;inverse tangent;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Input Value"}], "description": [{"code": "en-US", "content": "Calculates the arctangent (inverse tangent) of the input value."}]})
+class StdNumberArctan(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberArctan.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_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::number::as_text")
+@Signature("(number: NUMBER): TEXT")
+@Name({"code": "en-US", "content": "Number as Text"})
+@Description({"code": "en-US", "content": "Converts a number into text."})
+@DisplayMessage({"code": "en-US", "content": "Convert ${number} to Text"})
+@Alias({"code": "en-US", "content": "to text;string;format number;number;math;std;as;text"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "number", "name": [{"code": "en-US", "content": "Number"}], "description": [{"code": "en-US", "content": "The number to convert to text."}]})
+class StdNumberAsText(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberAsText.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_clamp.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 Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::number::clamp")
+@Signature("(value: NUMBER, min: NUMBER, max: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Clamp Number"})
+@Description({"code": "en-US", "content": "Returns the given number clamped between the minimum and maximum bounds."})
+@DisplayMessage({"code": "en-US", "content": "Clamp ${value} between ${min} and ${max}"})
+@Alias({"code": "en-US", "content": "clamp;limit;bound;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Number Input"}], "description": [{"code": "en-US", "content": "The input number that will be limited (clamped) to the specified range."}]})
+@Parameter({"runtime_name": "min", "name": [{"code": "en-US", "content": "Minimum"}], "description": [{"code": "en-US", "content": "The minimum allowed value in the clamping operation."}]})
+@Parameter({"runtime_name": "max", "name": [{"code": "en-US", "content": "Maximum"}], "description": [{"code": "en-US", "content": "The maximum allowed value in the clamping operation."}]})
+class StdNumberClamp(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberClamp.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_cos.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::number::cos")
+@Signature("(radians: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Cosine"})
+@Description({"code": "en-US", "content": "Calculates the cosine value of the input angle measured in radians."})
+@DisplayMessage({"code": "en-US", "content": "Cosine of ${radians}"})
+@Alias({"code": "en-US", "content": "cos;cosine;trigonometry;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "radians", "name": [{"code": "en-US", "content": "Radians"}], "description": [{"code": "en-US", "content": "Computes the cosine of the given angle in radians."}]})
+class StdNumberCos(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberCos.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_cosh.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::number::cosh")
+@Signature("(value: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Hyperbolic Cosine"})
+@Description({"code": "en-US", "content": "Calculates the hyperbolic cosine (cosh) of the input value."})
+@DisplayMessage({"code": "en-US", "content": "Hyperbolic Cosine of ${value}"})
+@Alias({"code": "en-US", "content": "cosh;hyperbolic cosine;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Number Input"}], "description": [{"code": "en-US", "content": "The number for which to calculate the hyperbolic cosine."}]})
+class StdNumberCosh(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberCosh.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_divide.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::number::divide")
+@Signature("(first: NUMBER, second: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Divide Numbers"})
+@Description({"code": "en-US", "content": "Returns the result of dividing the first numeric input (dividend) by the second (divisor)."})
+@DisplayMessage({"code": "en-US", "content": "${first} Divided by ${second}"})
+@Alias({"code": "en-US", "content": "divide;division;quotient;div;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@ThrowsError()
+@Parameter({"runtime_name": "first", "name": [{"code": "en-US", "content": "Dividend"}], "description": [{"code": "en-US", "content": "This is the numerator or the number that will be divided by the second value."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Divisor"}], "description": [{"code": "en-US", "content": "This is the denominator or the value that divides the first number."}]})
+class StdNumberDivide(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberDivide.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_euler.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::number::euler")
+@Signature("(): NUMBER")
+@Name({"code": "en-US", "content": "Euler's Number"})
+@Description({"code": "en-US", "content": "Provides the constant value of Euler's number, approximately 2.71828, which is the base of the natural logarithm."})
+@DisplayMessage({"code": "en-US", "content": "Euler's Number"})
+@Alias({"code": "en-US", "content": "euler;number;math;std"})
+@DisplayIcon("tabler:math-function")
+class StdNumberEuler(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberEuler.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_exponential.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::number::exponential")
+@Signature("(base: NUMBER, exponent: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Exponential"})
+@Description({"code": "en-US", "content": "Computes the result of raising the base to the power specified by the exponent."})
+@DisplayMessage({"code": "en-US", "content": "${base} to the Exponent of ${exponent}"})
+@Alias({"code": "en-US", "content": "exponential;exp;e power;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "base", "name": [{"code": "en-US", "content": "Base"}], "description": [{"code": "en-US", "content": "This is the numeric value that will be raised to the power of the exponent."}]})
+@Parameter({"runtime_name": "exponent", "name": [{"code": "en-US", "content": "Exponent"}], "description": [{"code": "en-US", "content": "This numeric value indicates the power to which the base is raised."}]})
+class StdNumberExponential(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberExponential.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_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::number::from_text")
+@Signature("(text: TEXT): NUMBER")
+@Name({"code": "en-US", "content": "Number from Text"})
+@Description({"code": "en-US", "content": "Attempts to parse the provided text input and return its numeric equivalent."})
+@DisplayMessage({"code": "en-US", "content": "Convert ${text} to Number"})
+@Alias({"code": "en-US", "content": "from text;parse;convert;number;math;std;from;text"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "text", "name": [{"code": "en-US", "content": "Text"}], "description": [{"code": "en-US", "content": "The text string to convert to a number."}]})
+class StdNumberFromText(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberFromText.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_has_digits.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::number::has_digits")
+@Signature("(number: NUMBER): BOOLEAN")
+@Name({"code": "en-US", "content": "Has Digits in Number"})
+@Description({"code": "en-US", "content": "Checks if the given number contains any digit characters"})
+@DisplayMessage({"code": "en-US", "content": "Does ${number} have digits"})
+@Alias({"code": "en-US", "content": "has;digits;contains;number;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "number", "name": [{"code": "en-US", "content": "Number Input"}], "description": [{"code": "en-US", "content": "The number to check for digit characters."}]})
+class StdNumberHasDigits(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberHasDigits.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_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::number::is_equal")
+@Signature("(first: NUMBER, second: NUMBER): BOOLEAN")
+@Name({"code": "en-US", "content": "Is Equal"})
+@Description({"code": "en-US", "content": "Returns true if the first number is equal to the second number, otherwise false."})
+@DisplayMessage({"code": "en-US", "content": "${first} Equals ${second}"})
+@Alias({"code": "en-US", "content": "equal;equals;same;number;math;std;is"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "first", "name": [{"code": "en-US", "content": "First Number"}], "description": [{"code": "en-US", "content": "The first number to compare."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Second Number"}], "description": [{"code": "en-US", "content": "The second number to compare."}]})
+class StdNumberIsEqual(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberIsEqual.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_is_greater.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::number::is_greater")
+@Signature("(first: NUMBER, second: NUMBER): BOOLEAN")
+@Name({"code": "en-US", "content": "Is Greater"})
+@Description({"code": "en-US", "content": "Returns true if the first numeric input is greater than the second; otherwise, returns false."})
+@DisplayMessage({"code": "en-US", "content": "${first} Is Greater than ${second}"})
+@Alias({"code": "en-US", "content": "greater;larger;more;number;math;std;is"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "first", "name": [{"code": "en-US", "content": "First Number"}], "description": [{"code": "en-US", "content": "This is the number that will be evaluated to determine if it is greater than the second number."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Second Number"}], "description": [{"code": "en-US", "content": "This is the number that the first number will be compared to."}]})
+class StdNumberIsGreater(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberIsGreater.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_is_less.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::number::is_less")
+@Signature("(first: NUMBER, second: NUMBER): BOOLEAN")
+@Name({"code": "en-US", "content": "Is Less"})
+@Description({"code": "en-US", "content": "Returns true if the first numeric input is less than the second; otherwise, returns false."})
+@DisplayMessage({"code": "en-US", "content": "${first} Less than ${second}"})
+@Alias({"code": "en-US", "content": "less;smaller;fewer;number;math;std;is"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "first", "name": [{"code": "en-US", "content": "First Number"}], "description": [{"code": "en-US", "content": "This is the number that will be evaluated to determine if it is less than the second number."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Second Number"}], "description": [{"code": "en-US", "content": "This is the number that the first number will be compared to."}]})
+class StdNumberIsLess(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberIsLess.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_is_positive.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::number::is_positive")
+@Signature("(value: NUMBER): BOOLEAN")
+@Name({"code": "en-US", "content": "Is Positive Number"})
+@Description({"code": "en-US", "content": "Evaluates the input number and returns true if it is positive (greater than zero), otherwise false."})
+@DisplayMessage({"code": "en-US", "content": "${value} Is Greater than 0"})
+@Alias({"code": "en-US", "content": "positive;greater than zero;number;math;std;is"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The number to check for positivity."}]})
+class StdNumberIsPositive(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberIsPositive.run() is not implemented")