code0-hercules 1.3.0__py3-none-any.whl

hercules/definitions/taurus_number/runtime_functions/std_number_is_zero.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_zero")
+@Signature("(value: NUMBER): BOOLEAN")
+@Name({"code": "en-US", "content": "Number Is Zero"})
+@Description({"code": "en-US", "content": "Returns true if the input number is zero. Otherwise returns false."})
+@DisplayMessage({"code": "en-US", "content": "${value} Equals 0"})
+@Alias({"code": "en-US", "content": "zero;equals zero;number;math;std;is"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "This is the numeric input evaluated to determine whether it equals zero."}]})
+class StdNumberIsZero(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberIsZero.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_ln.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::ln")
+@Signature("(value: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Natural Logarithm"})
+@Description({"code": "en-US", "content": "Calculates the natural logarithm (log base e) of a number."})
+@DisplayMessage({"code": "en-US", "content": "Natural Logarithm of ${value}"})
+@Alias({"code": "en-US", "content": "natural log;ln;log e;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Input Number"}], "description": [{"code": "en-US", "content": "The numeric input whose natural logarithm (log base e) will be calculated."}]})
+class StdNumberLn(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberLn.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_log.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::log")
+@Signature("(value: NUMBER, base: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Logarithm"})
+@Description({"code": "en-US", "content": "Calculates and returns the logarithm of a number with respect to a specified base."})
+@DisplayMessage({"code": "en-US", "content": "Logarithm with Base ${base} of ${value}"})
+@Alias({"code": "en-US", "content": "log;logarithm;log base;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The numeric input whose logarithm is to be calculated."}]})
+@Parameter({"runtime_name": "base", "name": [{"code": "en-US", "content": "Base"}], "description": [{"code": "en-US", "content": "Specifies the logarithmic base to use (e.g., 10 for common log, e for natural log)."}]})
+class StdNumberLog(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberLog.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_max.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::max")
+@Signature("(first: NUMBER, second: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Maximum Number"})
+@Description({"code": "en-US", "content": "Compares two numbers and returns the maximum value."})
+@DisplayMessage({"code": "en-US", "content": "Maximum of ${first} and ${second}"})
+@Alias({"code": "en-US", "content": "max;maximum;largest;greatest;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 compare."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Second Number"}], "description": [{"code": "en-US", "content": "The second number to compare."}]})
+class StdNumberMax(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberMax.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_min.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::min")
+@Signature("(first: NUMBER, second: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Minimum"})
+@Description({"code": "en-US", "content": "Compares two numbers and returns the minimum value."})
+@DisplayMessage({"code": "en-US", "content": "Minimum of ${first} and ${second}"})
+@Alias({"code": "en-US", "content": "min;minimum;smallest;least;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 compare."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Second Number"}], "description": [{"code": "en-US", "content": "The second number to compare."}]})
+class StdNumberMin(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberMin.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_modulo.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::modulo")
+@Signature("(first: NUMBER, second: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Modulo"})
+@Description({"code": "en-US", "content": "Computes the modulus (remainder) of dividing the first numeric input by the second."})
+@DisplayMessage({"code": "en-US", "content": "${first} Modulus ${second}"})
+@Alias({"code": "en-US", "content": "modulo;mod;remainder;modulus;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "first", "name": [{"code": "en-US", "content": "Number"}], "description": [{"code": "en-US", "content": "The number to apply the modulo operator onto."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Modulo"}], "description": [{"code": "en-US", "content": "The modulo operator."}]})
+class StdNumberModulo(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberModulo.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_multiply.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::multiply")
+@Signature("(first: NUMBER, second: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Multiply"})
+@Description({"code": "en-US", "content": "Takes two numeric inputs and returns their product."})
+@DisplayMessage({"code": "en-US", "content": "${first} Multiply by ${second}"})
+@Alias({"code": "en-US", "content": "multiply;times;product;mul;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 multiply."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Second Number"}], "description": [{"code": "en-US", "content": "The second number to multiply."}]})
+class StdNumberMultiply(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberMultiply.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_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::number::negate")
+@Signature("(value: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Negate"})
+@Description({"code": "en-US", "content": "Returns the negation of a number (multiplies by -1)."})
+@DisplayMessage({"code": "en-US", "content": "Negate ${value}"})
+@Alias({"code": "en-US", "content": "negate;negative;invert;opposite;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The number to negate."}]})
+class StdNumberNegate(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberNegate.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_pi.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::pi")
+@Signature("(): NUMBER")
+@Name({"code": "en-US", "content": "Pi"})
+@Description({"code": "en-US", "content": "Provides the constant value of pi, approximately 3.14159, used in many mathematical calculations."})
+@DisplayMessage({"code": "en-US", "content": "Pi"})
+@Alias({"code": "en-US", "content": "pi;number;math;std"})
+@DisplayIcon("tabler:math-function")
+class StdNumberPi(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberPi.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_random_number.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::random_number")
+@Signature("(min: NUMBER, max: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Random Number"})
+@Description({"code": "en-US", "content": "Returns a randomly generated number within the given range, inclusive of both minimum and maximum."})
+@DisplayMessage({"code": "en-US", "content": "Random Number Between ${min} and ${max}"})
+@Alias({"code": "en-US", "content": "random;rand;random number;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "min", "name": [{"code": "en-US", "content": "Minimum Value"}], "description": [{"code": "en-US", "content": "Defines the lower bound (inclusive) for the random number generation."}]})
+@Parameter({"runtime_name": "max", "name": [{"code": "en-US", "content": "Maximum Value"}], "description": [{"code": "en-US", "content": "Defines the upper bound (inclusive) for the random number generation."}]})
+class StdNumberRandomNumber(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberRandomNumber.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_remove_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::remove_digits")
+@Signature("(number: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Remove Digits from Number"})
+@Description({"code": "en-US", "content": "Removes all digit characters from the input number, effectively stripping it down to its non-digit components."})
+@DisplayMessage({"code": "en-US", "content": "Remove Digits from ${number}"})
+@Alias({"code": "en-US", "content": "remove:digits;strip;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "number", "name": [{"code": "en-US", "content": "Number Input"}], "description": [{"code": "en-US", "content": "This is the numeric input. The result will be its value without any digits."}]})
+class StdNumberRemoveDigits(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberRemoveDigits.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_root.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::root")
+@Signature("(value: NUMBER, root_exponent: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Root"})
+@Description({"code": "en-US", "content": "Calculates the nth root of the input number, where n is specified by the root exponent."})
+@DisplayMessage({"code": "en-US", "content": "${root_exponent} Root of ${value}"})
+@Alias({"code": "en-US", "content": "root;nth root;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Input Value"}], "description": [{"code": "en-US", "content": "The numeric input for which the root will be calculated."}]})
+@Parameter({"runtime_name": "root_exponent", "name": [{"code": "en-US", "content": "Root Exponent"}], "description": [{"code": "en-US", "content": "The degree of the root to extract."}]})
+class StdNumberRoot(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberRoot.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_round.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::round")
+@Signature("(value: NUMBER, decimals: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Round Number"})
+@Description({"code": "en-US", "content": "Rounds a number to the nearest value at the specified number of decimal places."})
+@DisplayMessage({"code": "en-US", "content": "Round ${value} with ${decimals} Decimal Places"})
+@Alias({"code": "en-US", "content": "round;nearest;approximate;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The numeric input that will be rounded to the nearest value."}]})
+@Parameter({"runtime_name": "decimals", "name": [{"code": "en-US", "content": "Decimal Places"}], "description": [{"code": "en-US", "content": "Specifies how many decimal digits to keep after rounding."}]})
+class StdNumberRound(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberRound.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_round_down.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::round_down")
+@Signature("(value: NUMBER, decimals: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Round Number Down"})
+@Description({"code": "en-US", "content": "Rounds a number downward to the specified number of decimal places."})
+@DisplayMessage({"code": "en-US", "content": "Round Down ${value} with ${decimals} Decimal Places"})
+@Alias({"code": "en-US", "content": "round down;floor;number;math;std;round;down"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The numeric input that will be rounded downwards."}]})
+@Parameter({"runtime_name": "decimals", "name": [{"code": "en-US", "content": "Decimal Places"}], "description": [{"code": "en-US", "content": "Specifies how many decimal digits to keep after rounding down."}]})
+class StdNumberRoundDown(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberRoundDown.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_round_up.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::round_up")
+@Signature("(value: NUMBER, decimals: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Round Up"})
+@Description({"code": "en-US", "content": "Performs rounding on the given value, always rounding up to the nearest value at the given decimal precision."})
+@DisplayMessage({"code": "en-US", "content": "Round Upwards ${value} with ${decimals} Decimal Places"})
+@Alias({"code": "en-US", "content": "round up;ceil;ceiling;number;math;std;round;up"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Number Input"}], "description": [{"code": "en-US", "content": "The number to be rounded up."}]})
+@Parameter({"runtime_name": "decimals", "name": [{"code": "en-US", "content": "Decimal Places"}], "description": [{"code": "en-US", "content": "The number of decimal places to round up to."}]})
+class StdNumberRoundUp(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberRoundUp.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_sin.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::sin")
+@Signature("(value: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Sine"})
+@Description({"code": "en-US", "content": "Calculates the sine of the input value."})
+@DisplayMessage({"code": "en-US", "content": "Sine of ${value}"})
+@Alias({"code": "en-US", "content": "sin;sine;trigonometry;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 sine."}]})
+class StdNumberSin(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberSin.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_sinh.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::sinh")
+@Signature("(value: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Hyperbolic Sine"})
+@Description({"code": "en-US", "content": "Calculates the hyperbolic sine (sinh) of the input value."})
+@DisplayMessage({"code": "en-US", "content": "Hyperbolic Sine of ${value}"})
+@Alias({"code": "en-US", "content": "sinh;hyperbolic sine;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 sine."}]})
+class StdNumberSinh(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberSinh.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_square.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::square")
+@Signature("(value: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Square"})
+@Description({"code": "en-US", "content": "Returns the square of the given number."})
+@DisplayMessage({"code": "en-US", "content": "${value} Squared"})
+@Alias({"code": "en-US", "content": "square;squared;power two;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The number to be squared."}]})
+class StdNumberSquare(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberSquare.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_square_root.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::square_root")
+@Signature("(value: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Square Root"})
+@Description({"code": "en-US", "content": "Calculates the positive square root of the input number."})
+@DisplayMessage({"code": "en-US", "content": "Square Root of ${value}"})
+@Alias({"code": "en-US", "content": "square root;sqrt;root;number;math;std;square"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The number to find the square root of."}]})
+class StdNumberSquareRoot(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberSquareRoot.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_subtract.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::subtract")
+@Signature("(first: NUMBER, second: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Subtract"})
+@Description({"code": "en-US", "content": "Subtracts the second number from the first number."})
+@DisplayMessage({"code": "en-US", "content": "${first} Minus ${second}"})
+@Alias({"code": "en-US", "content": "subtract;minus;difference;sub;number;math;std"})
+@DisplayIcon("tabler:math-function")
+@Parameter({"runtime_name": "first", "name": [{"code": "en-US", "content": "Minuend"}], "description": [{"code": "en-US", "content": "The number from which another number (the subtrahend) is to be subtracted."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Subtrahend"}], "description": [{"code": "en-US", "content": "The number to subtract from the first number (the minuend)."}]})
+class StdNumberSubtract(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberSubtract.run() is not implemented")

hercules/definitions/taurus_number/runtime_functions/std_number_tan.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::tan")
+@Signature("(radians: NUMBER): NUMBER")
+@Name({"code": "en-US", "content": "Tangent"})
+@Description({"code": "en-US", "content": "Calculates the tangent value of the input angle measured in radians."})
+@DisplayMessage({"code": "en-US", "content": "Tangent of ${radians}"})
+@Alias({"code": "en-US", "content": "tan;tangent;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 tangent of the given angle in radians."}]})
+class StdNumberTan(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdNumberTan.run() is not implemented")

hercules/definitions/taurus_object/data_types/object.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Object(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+
+
+from hercules.internal.schema import register_schema
+register_schema(Object, "OBJECT")

hercules/definitions/taurus_object/data_types/type.py

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

hercules/definitions/taurus_object/runtime_functions/std_object_contains_key.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::object::contains_key")
+@Signature("<T>(object: OBJECT<T>, key: keyof OBJECT<T> | string): BOOLEAN")
+@Name({"code": "en-US", "content": "Contains Key"})
+@Description({"code": "en-US", "content": "Returns true if the given key is a property of the object; otherwise, returns false."})
+@DisplayMessage({"code": "en-US", "content": "Checks if ${object} Contains ${key}"})
+@Alias({"code": "en-US", "content": "contains_key;object;std;contains;key"})
+@DisplayIcon("tabler:cube")
+@Parameter({"runtime_name": "object", "name": [{"code": "en-US", "content": "Object"}], "description": [{"code": "en-US", "content": "The object to check for the presence of a key."}]})
+@Parameter({"runtime_name": "key", "name": [{"code": "en-US", "content": "Key"}], "description": [{"code": "en-US", "content": "The key to check for existence in the object."}]})
+class StdObjectContainsKey(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdObjectContainsKey.run() is not implemented")

hercules/definitions/taurus_object/runtime_functions/std_object_get.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::object::get")
+@Signature("<T, K extends keyof T>(object: OBJECT<T>, key: K | string): T[K]")
+@Name({"code": "en-US", "content": "Get key of object"})
+@Description({"code": "en-US", "content": "Returns the value of a key inside of the object."})
+@DisplayMessage({"code": "en-US", "content": "Get ${key} of ${object}"})
+@Alias({"code": "en-US", "content": "get;object;std"})
+@DisplayIcon("tabler:cube")
+@Parameter({"runtime_name": "object", "name": [{"code": "en-US", "content": "Object"}], "description": [{"code": "en-US", "content": "The object that contains the value referenced by the key."}]})
+@Parameter({"runtime_name": "key", "name": [{"code": "en-US", "content": "Key"}], "description": [{"code": "en-US", "content": "The property name under which the value will be referenced."}]})
+class StdObjectGet(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdObjectGet.run() is not implemented")

hercules/definitions/taurus_object/runtime_functions/std_object_keys.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::object::keys")
+@Signature("<T>(object: OBJECT<T>): LIST<keyof OBJECT<T>>")
+@Name({"code": "en-US", "content": "Get Object Keys"})
+@Description({"code": "en-US", "content": "Returns a list containing all keys of the specified object."})
+@DisplayMessage({"code": "en-US", "content": "Keys of ${object}"})
+@Alias({"code": "en-US", "content": "keys;object;std"})
+@DisplayIcon("tabler:cube")
+@Parameter({"runtime_name": "object", "name": [{"code": "en-US", "content": "Object"}], "description": [{"code": "en-US", "content": "Returns a list of all the keys (property names) of the given object."}]})
+class StdObjectKeys(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdObjectKeys.run() is not implemented")

hercules/definitions/taurus_object/runtime_functions/std_object_set.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::object::set")
+@Signature("<T, K extends TEXT, V>(object: OBJECT<T>, key: K, value: V): OBJECT<T & { [P in K]: V }>")
+@Name({"code": "en-US", "content": "Set Object Key"})
+@Description({"code": "en-US", "content": "Returns a new object with the specified key set to the given value."})
+@DisplayMessage({"code": "en-US", "content": "Set ${key} to ${value} of ${object}"})
+@Alias({"code": "en-US", "content": "set;object;std"})
+@DisplayIcon("tabler:cube")
+@Parameter({"runtime_name": "object", "name": [{"code": "en-US", "content": "Object"}], "description": [{"code": "en-US", "content": "The original object that will be modified with the specified key-value pair."}]})
+@Parameter({"runtime_name": "key", "name": [{"code": "en-US", "content": "Key"}], "description": [{"code": "en-US", "content": "The property name under which the value will be stored in the object."}]})
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Value"}], "description": [{"code": "en-US", "content": "The value to assign to the object property identified by the key."}]})
+class StdObjectSet(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdObjectSet.run() is not implemented")

hercules/definitions/taurus_object/runtime_functions/std_object_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::object::size")
+@Signature("<T>(object: OBJECT<T>): NUMBER")
+@Name({"code": "en-US", "content": "Get Object Size"})
+@Description({"code": "en-US", "content": "Returns an integer count of all enumerable property keys in the specified object."})
+@DisplayMessage({"code": "en-US", "content": "Size of ${object}"})
+@Alias({"code": "en-US", "content": "size;object;std"})
+@DisplayIcon("tabler:cube")
+@Parameter({"runtime_name": "object", "name": [{"code": "en-US", "content": "Object"}], "description": [{"code": "en-US", "content": "Returns the number of keys present in the given object."}]})
+class StdObjectSize(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdObjectSize.run() is not implemented")

hercules/definitions/taurus_text/data_types/text.py

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

hercules/definitions/taurus_text/data_types/text_encoding.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import RootModel
+
+
+class TextEncoding(RootModel[Literal['BASE64']]):
+    root: Literal['BASE64']
+
+
+from hercules.internal.schema import register_schema
+register_schema(TextEncoding, "TEXT_ENCODING")