code0-hercules 1.3.0__py3-none-any.whl

hercules/definitions/taurus_text/runtime_functions/std_text_append.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::text::append")
+@Signature("(value: TEXT, suffix: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Append Text"})
+@Description({"code": "en-US", "content": "Returns a new text consisting of the original text followed by the specified suffix."})
+@DisplayMessage({"code": "en-US", "content": "Append ${suffix} at the End of ${value}"})
+@Alias({"code": "en-US", "content": "append;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Original Text"}], "description": [{"code": "en-US", "content": "The base text that will have another text appended to its end."}]})
+@Parameter({"runtime_name": "suffix", "name": [{"code": "en-US", "content": "Suffix"}], "description": [{"code": "en-US", "content": "The text that will be appended to the end of the original text."}]})
+class StdTextAppend(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextAppend.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_as_bytes.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::text::as_bytes")
+@Signature("(value: TEXT): LIST<NUMBER>")
+@Name({"code": "en-US", "content": "Text As Bytes"})
+@Description({"code": "en-US", "content": "Converts a text into a list of byte values."})
+@DisplayMessage({"code": "en-US", "content": "${value} As Bytes"})
+@Alias({"code": "en-US", "content": "as_bytes;text;string;std;as;bytes"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text Value"}], "description": [{"code": "en-US", "content": "Converts the input text into a list of byte values."}]})
+class StdTextAsBytes(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextAsBytes.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_at.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::text::at")
+@Signature("(value: TEXT, index: NUMBER): TEXT")
+@Name({"code": "en-US", "content": "Character at Index"})
+@Description({"code": "en-US", "content": "Retrieves a single character from the input text based on the provided zero-based index."})
+@DisplayMessage({"code": "en-US", "content": "Get Character of ${value} at ${index}"})
+@Alias({"code": "en-US", "content": "at;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text Value"}], "description": [{"code": "en-US", "content": "The input text from which a character will be retrieved by index."}]})
+@Parameter({"runtime_name": "index", "name": [{"code": "en-US", "content": "Index"}], "description": [{"code": "en-US", "content": "The zero-based position of the character to extract."}]})
+class StdTextAt(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextAt.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_byte_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::text::byte_size")
+@Signature("(value: TEXT): NUMBER")
+@Name({"code": "en-US", "content": "Byte Size"})
+@Description({"code": "en-US", "content": "Computes the size in bytes of the provided text."})
+@DisplayMessage({"code": "en-US", "content": "Byte-Size of ${value}"})
+@Alias({"code": "en-US", "content": "byte_size;text;string;std;byte;size"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text Value"}], "description": [{"code": "en-US", "content": "The text whose byte size is to be calculated."}]})
+class StdTextByteSize(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextByteSize.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_capitalize.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::text::capitalize")
+@Signature("(value: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Capitalize"})
+@Description({"code": "en-US", "content": "Converts the first character of the text to uppercase and leaves the rest unchanged."})
+@DisplayMessage({"code": "en-US", "content": "Capitalize ${value}"})
+@Alias({"code": "en-US", "content": "capitalize;title case;upper first;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text Value"}], "description": [{"code": "en-US", "content": "Capitalizes the first letter of the input text."}]})
+class StdTextCapitalize(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextCapitalize.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_chars.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::text::chars")
+@Signature("(value: TEXT): LIST<TEXT>")
+@Name({"code": "en-US", "content": "Characters"})
+@Description({"code": "en-US", "content": "Creates a list where each element is a single character from the original text."})
+@DisplayMessage({"code": "en-US", "content": "Turns ${value} into a List of Characters"})
+@Alias({"code": "en-US", "content": "characters;letters;split;text;string;std;chars"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text Value"}], "description": [{"code": "en-US", "content": "Splits the input text into a list of its constituent characters."}]})
+class StdTextChars(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextChars.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_contains.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::text::contains")
+@Signature("(value: TEXT, substring: TEXT): BOOLEAN")
+@Name({"code": "en-US", "content": "Contains Text"})
+@Description({"code": "en-US", "content": "Returns true if the subtext is found anywhere in the main text. Otherwise, returns false."})
+@DisplayMessage({"code": "en-US", "content": "Check if ${value} contains ${substring}"})
+@Alias({"code": "en-US", "content": "contains;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text"}], "description": [{"code": "en-US", "content": "The main text to search within."}]})
+@Parameter({"runtime_name": "substring", "name": [{"code": "en-US", "content": "Subtext"}], "description": [{"code": "en-US", "content": "The text to search for inside the main text."}]})
+class StdTextContains(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextContains.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_decode.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::text::decode")
+@Signature("(value: TEXT, encoding: TEXT_ENCODING): TEXT")
+@Name({"code": "en-US", "content": "Decode Text"})
+@Description({"code": "en-US", "content": "Decodes the input text from the specified encoding format."})
+@DisplayMessage({"code": "en-US", "content": "Decode ${value} using ${encoding}"})
+@Alias({"code": "en-US", "content": "decode;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text"}], "description": [{"code": "en-US", "content": "The text to decode."}]})
+@Parameter({"runtime_name": "encoding", "name": [{"code": "en-US", "content": "Encoding Type"}], "description": [{"code": "en-US", "content": "The decoding scheme to apply (e.g. Base64)."}]})
+class StdTextDecode(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextDecode.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_encode.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::text::encode")
+@Signature("(value: TEXT, encoding: TEXT_ENCODING): TEXT")
+@Name({"code": "en-US", "content": "Encode Text"})
+@Description({"code": "en-US", "content": "Transforms the given text into a representation encoded by the specified encoding scheme."})
+@DisplayMessage({"code": "en-US", "content": "Encode ${value} to ${encoding}"})
+@Alias({"code": "en-US", "content": "encode;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text"}], "description": [{"code": "en-US", "content": "The text to encode."}]})
+@Parameter({"runtime_name": "encoding", "name": [{"code": "en-US", "content": "Encoding Type"}], "description": [{"code": "en-US", "content": "The encoding scheme to apply (e.g., UTF-8, Base64)."}]})
+class StdTextEncode(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextEncode.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_ends_with.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::text::ends_with")
+@Signature("(value: TEXT, suffix: TEXT): BOOLEAN")
+@Name({"code": "en-US", "content": "Ends With"})
+@Description({"code": "en-US", "content": "Returns true if the input text ends with the given suffix. Otherwise, returns false."})
+@DisplayMessage({"code": "en-US", "content": "Check if ${value} Ends With ${suffix}"})
+@Alias({"code": "en-US", "content": "ends_with;text;string;std;ends;with"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text"}], "description": [{"code": "en-US", "content": "The input text to check."}]})
+@Parameter({"runtime_name": "suffix", "name": [{"code": "en-US", "content": "Suffix"}], "description": [{"code": "en-US", "content": "The suffix to test against the input text."}]})
+class StdTextEndsWith(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextEndsWith.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_from_ascii.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::text::from_ascii")
+@Signature("(value: LIST<NUMBER>): TEXT")
+@Name({"code": "en-US", "content": "Text from ASCII"})
+@Description({"code": "en-US", "content": "Converts a list of ASCII codes back into the corresponding text."})
+@DisplayMessage({"code": "en-US", "content": "${value} to Text"})
+@Alias({"code": "en-US", "content": "from_ascii;text;string;std;from;ascii"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "ASCII Code"}], "description": [{"code": "en-US", "content": "List of ASCII numeric codes representing characters."}]})
+class StdTextFromAscii(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextFromAscii.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_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::text::hex")
+@Signature("(value: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Text to Hexadecimal"})
+@Description({"code": "en-US", "content": "Returns a text containing the hexadecimal values corresponding to each character of the input text."})
+@DisplayMessage({"code": "en-US", "content": "${value} to Hexadecimal"})
+@Alias({"code": "en-US", "content": "hex;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Input Text"}], "description": [{"code": "en-US", "content": "The text to be converted to its hexadecimal representation."}]})
+class StdTextHex(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextHex.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_index_of.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::text::index_of")
+@Signature("(value: TEXT, substring: TEXT): NUMBER")
+@Name({"code": "en-US", "content": "Index Of"})
+@Description({"code": "en-US", "content": "Returns the zero-based index of the first occurrence of the subtext in the text. Returns -1 if the subtext is not found."})
+@DisplayMessage({"code": "en-US", "content": "Get Position of ${substring} Inside ${value}"})
+@Alias({"code": "en-US", "content": "index_of;text;string;std;index;of"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text"}], "description": [{"code": "en-US", "content": "The text to search within."}]})
+@Parameter({"runtime_name": "substring", "name": [{"code": "en-US", "content": "Subtext"}], "description": [{"code": "en-US", "content": "The subtext to find inside the text."}]})
+class StdTextIndexOf(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextIndexOf.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_insert.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::text::insert")
+@Signature("(value: TEXT, position: NUMBER, text: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Insert Text"})
+@Description({"code": "en-US", "content": "Returns a new text where the provided text is inserted at the zero-based position index within the original text."})
+@DisplayMessage({"code": "en-US", "content": "Insert ${value} at ${position} into ${text}"})
+@Alias({"code": "en-US", "content": "insert;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Original Text"}], "description": [{"code": "en-US", "content": "The original text into which another text will be inserted."}]})
+@Parameter({"runtime_name": "position", "name": [{"code": "en-US", "content": "Position"}], "description": [{"code": "en-US", "content": "Zero-based index indicating where the new text should be inserted."}]})
+@Parameter({"runtime_name": "text", "name": [{"code": "en-US", "content": "Text to Insert"}], "description": [{"code": "en-US", "content": "The text that will be inserted into the original text."}]})
+class StdTextInsert(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextInsert.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_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::text::is_equal")
+@Signature("(first: TEXT, second: TEXT): BOOLEAN")
+@Name({"code": "en-US", "content": "Is Equal"})
+@Description({"code": "en-US", "content": "Determines if the two given text inputs are exactly the same, returning true if equal, false otherwise."})
+@DisplayMessage({"code": "en-US", "content": "${first} Equals ${second}"})
+@Alias({"code": "en-US", "content": "equal;equals;same;text;string;std;is"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "first", "name": [{"code": "en-US", "content": "First Text"}], "description": [{"code": "en-US", "content": "The first text to compare."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Second Text"}], "description": [{"code": "en-US", "content": "The second text to compare."}]})
+class StdTextIsEqual(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextIsEqual.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_length.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::text::length")
+@Signature("(value: TEXT): NUMBER")
+@Name({"code": "en-US", "content": "Length"})
+@Description({"code": "en-US", "content": "Returns the number of characters in the given text."})
+@DisplayMessage({"code": "en-US", "content": "Length of ${value}"})
+@Alias({"code": "en-US", "content": "length;size;characters;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text"}], "description": [{"code": "en-US", "content": "Input text to determine the number of characters it contains."}]})
+class StdTextLength(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextLength.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_lowercase.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::text::lowercase")
+@Signature("(value: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Text to Lowercase"})
+@Description({"code": "en-US", "content": "Returns a new text with all characters converted to lowercase."})
+@DisplayMessage({"code": "en-US", "content": "${value} to Lowercase"})
+@Alias({"code": "en-US", "content": "lowercase;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text Value"}], "description": [{"code": "en-US", "content": "Converts all characters in the input text to lowercase."}]})
+class StdTextLowercase(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextLowercase.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_octal.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::text::octal")
+@Signature("(value: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Text to Octal"})
+@Description({"code": "en-US", "content": "Converts a text into an octal representation."})
+@DisplayMessage({"code": "en-US", "content": "${value} to Octal"})
+@Alias({"code": "en-US", "content": "octal;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Input Text"}], "description": [{"code": "en-US", "content": "The text to be converted to its octal representation."}]})
+class StdTextOctal(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextOctal.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_prepend.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::text::prepend")
+@Signature("(value: TEXT, prefix: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Prepend Text"})
+@Description({"code": "en-US", "content": "Returns a new text consisting of the specified prefix followed by the original text."})
+@DisplayMessage({"code": "en-US", "content": "Prepend ${value} with ${prefix}"})
+@Alias({"code": "en-US", "content": "prepend;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Original Text"}], "description": [{"code": "en-US", "content": "The base text that will have another text prepended to its beginning."}]})
+@Parameter({"runtime_name": "prefix", "name": [{"code": "en-US", "content": "Prefix"}], "description": [{"code": "en-US", "content": "The text that will be added to the start of the original text."}]})
+class StdTextPrepend(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextPrepend.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_remove.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::text::remove")
+@Signature("(value: TEXT, start: NUMBER, end: NUMBER): TEXT")
+@Name({"code": "en-US", "content": "Remove String"})
+@Description({"code": "en-US", "content": "Removes the subtext between the specified start and end indices from the input text."})
+@DisplayMessage({"code": "en-US", "content": "Remove ${value} from ${start}"})
+@Alias({"code": "en-US", "content": "remove;delete;strip;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text"}], "description": [{"code": "en-US", "content": "The input text from which a subtext will be removed."}]})
+@Parameter({"runtime_name": "start", "name": [{"code": "en-US", "content": "Start Index"}], "description": [{"code": "en-US", "content": "The starting position for removing characters from the text."}]})
+@Parameter({"runtime_name": "end", "name": [{"code": "en-US", "content": "End Index"}], "description": [{"code": "en-US", "content": "The zero-based index where removal ends (exclusive)."}]})
+class StdTextRemove(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextRemove.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_replace.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::text::replace")
+@Signature("(value: TEXT, oldText: TEXT, newText: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Replace Subtext"})
+@Description({"code": "en-US", "content": "Returns a new text where every instance of the old subtext is replaced by the new subtext."})
+@DisplayMessage({"code": "en-US", "content": "Replace ${old} with ${new} Inside ${value}"})
+@Alias({"code": "en-US", "content": "replace;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Original Text"}], "description": [{"code": "en-US", "content": "This is the text in which all occurrences of the old subtext will be replaced."}]})
+@Parameter({"runtime_name": "oldText", "name": [{"code": "en-US", "content": "Old Subtext"}], "description": [{"code": "en-US", "content": "All occurrences of this subtext in the original text will be replaced."}]})
+@Parameter({"runtime_name": "newText", "name": [{"code": "en-US", "content": "New Subtext"}], "description": [{"code": "en-US", "content": "This subtext will replace each occurrence of the old subtext."}]})
+class StdTextReplace(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextReplace.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_replace_first.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::text::replace_first")
+@Signature("(value: TEXT, oldText: TEXT, newText: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Replace First Subtext"})
+@Description({"code": "en-US", "content": "Replaces the first occurrence of a specified subtext with another subtext in the input text."})
+@Documentation({"code": "en-US", "content": "Returns a new text where only the first instance of the old subtext is replaced by the new subtext."})
+@DisplayMessage({"code": "en-US", "content": "In ${value} replace first ${old} with ${new}"})
+@Alias({"code": "en-US", "content": "replace_first;text;string;std;replace;first"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Original Text"}], "description": [{"code": "en-US", "content": "This text contains the subtext that will be replaced only once\u2014the first occurrence."}]})
+@Parameter({"runtime_name": "oldText", "name": [{"code": "en-US", "content": "Old Subtext"}], "description": [{"code": "en-US", "content": "Only the first occurrence of this subtext will be replaced in the original text."}]})
+@Parameter({"runtime_name": "newText", "name": [{"code": "en-US", "content": "New Subtext"}], "description": [{"code": "en-US", "content": "This subtext will replace only the first occurrence of the old subtext."}]})
+class StdTextReplaceFirst(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextReplaceFirst.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_replace_last.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::text::replace_last")
+@Signature("(value: TEXT, oldText: TEXT, newText: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Replace Last Text"})
+@Description({"code": "en-US", "content": "Replaces the last occurrence of a specified subtext with another subtext in the input text."})
+@DisplayMessage({"code": "en-US", "content": "In ${value} replace the last ${old} with ${new}"})
+@Alias({"code": "en-US", "content": "replace_last;text;string;std;replace;last"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Original Text"}], "description": [{"code": "en-US", "content": "This text contains the subtext that will be replaced only once\u2014the last occurrence."}]})
+@Parameter({"runtime_name": "oldText", "name": [{"code": "en-US", "content": "Old Subtext"}], "description": [{"code": "en-US", "content": "Only the last occurrence of this subtext will be replaced in the original text."}]})
+@Parameter({"runtime_name": "newText", "name": [{"code": "en-US", "content": "New Subtext"}], "description": [{"code": "en-US", "content": "This subtext will replace only the last occurrence of the old subtext."}]})
+class StdTextReplaceLast(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextReplaceLast.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_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::text::reverse")
+@Signature("(value: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Reverse Text"})
+@Description({"code": "en-US", "content": "Returns a new text with the characters of the input text in reverse order."})
+@DisplayMessage({"code": "en-US", "content": "Reverse ${value}"})
+@Alias({"code": "en-US", "content": "reverse;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text"}], "description": [{"code": "en-US", "content": "The input text to be reversed."}]})
+class StdTextReverse(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextReverse.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_split.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::text::split")
+@Signature("(value: TEXT, delimiter: TEXT): LIST<TEXT>")
+@Name({"code": "en-US", "content": "Split"})
+@Description({"code": "en-US", "content": "Returns a list of subtext obtained by splitting the input text at each occurrence of the delimiter."})
+@DisplayMessage({"code": "en-US", "content": "Splits ${value} on '${delimiter}'"})
+@Alias({"code": "en-US", "content": "split;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text"}], "description": [{"code": "en-US", "content": "The input text to be split."}]})
+@Parameter({"runtime_name": "delimiter", "name": [{"code": "en-US", "content": "Delimiter"}], "description": [{"code": "en-US", "content": "The delimiter text to split the text by."}]})
+class StdTextSplit(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextSplit.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_starts_with.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::text::starts_with")
+@Signature("(value: TEXT, prefix: TEXT): BOOLEAN")
+@Name({"code": "en-US", "content": "Starts With"})
+@Description({"code": "en-US", "content": "Returns true if the input text begins with the given prefix. Otherwise, returns false."})
+@DisplayMessage({"code": "en-US", "content": "Check if ${value} starts with ${prefix}"})
+@Alias({"code": "en-US", "content": "text;string;std;start;with;starts"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text"}], "description": [{"code": "en-US", "content": "The input text to check."}]})
+@Parameter({"runtime_name": "prefix", "name": [{"code": "en-US", "content": "Prefix"}], "description": [{"code": "en-US", "content": "The prefix to test against the input text."}]})
+class StdTextStartsWith(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextStartsWith.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_swapcase.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::text::swapcase")
+@Signature("(value: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Swap Case"})
+@Description({"code": "en-US", "content": "Converts uppercase letters to lowercase and lowercase letters to uppercase in the given text."})
+@DisplayMessage({"code": "en-US", "content": "Swapcase of ${value}"})
+@Alias({"code": "en-US", "content": "swapcase;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text Value"}], "description": [{"code": "en-US", "content": "Swaps the case of each letter in the input text: uppercase letters become lowercase, and vice versa."}]})
+class StdTextSwapcase(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextSwapcase.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_to_ascii.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::text::to_ascii")
+@Signature("(value: TEXT): LIST<NUMBER>")
+@Name({"code": "en-US", "content": "Text to ASCII"})
+@Description({"code": "en-US", "content": "Returns a list of numbers where each number represents the ASCII code of the corresponding character in the input text."})
+@DisplayMessage({"code": "en-US", "content": "${value} To Ascii"})
+@Alias({"code": "en-US", "content": "to_ascii;text;string;std;to;ascii"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text"}], "description": [{"code": "en-US", "content": "Input text to convert to ASCII codes."}]})
+class StdTextToAscii(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextToAscii.run() is not implemented")

hercules/definitions/taurus_text/runtime_functions/std_text_trim.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::text::trim")
+@Signature("(value: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Trim Text"})
+@Description({"code": "en-US", "content": "Returns a new text with all leading and trailing whitespace characters removed from the input text."})
+@DisplayMessage({"code": "en-US", "content": "Trim ${value}"})
+@Alias({"code": "en-US", "content": "trim;text;string;std"})
+@DisplayIcon("tabler:abc")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Text Value"}], "description": [{"code": "en-US", "content": "The input text from which leading and trailing whitespace characters will be removed."}]})
+class StdTextTrim(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdTextTrim.run() is not implemented")