code0-hercules 1.3.0__py3-none-any.whl

hercules/definitions/taurus_date/runtime_functions/std_date_from_unix.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::date::from_unix")
+@Signature("(value: NUMBER): DATE")
+@Name({"code": "en-US", "content": "Date from Unix Timestamp"})
+@Description({"code": "en-US", "content": "Creates a date from a Unix timestamp given in seconds since the Unix epoch."})
+@DisplayMessage({"code": "en-US", "content": "Date from Unix timestamp ${value}"})
+@Alias({"code": "en-US", "content": "from unix;unix;timestamp;epoch;from;date;time;std"})
+@DisplayIcon("tabler:calendar-plus")
+@Parameter({"runtime_name": "value", "name": [{"code": "en-US", "content": "Unix Timestamp"}], "description": [{"code": "en-US", "content": "The Unix timestamp in seconds since the Unix epoch (1970-01-01T00:00:00Z)."}]})
+class StdDateFromUnix(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdDateFromUnix.run() is not implemented")

hercules/definitions/taurus_date/runtime_functions/std_date_now.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::date::now")
+@Signature("(): DATE")
+@Name({"code": "en-US", "content": "Now"})
+@Description({"code": "en-US", "content": "Returns the current date and time as a date."})
+@DisplayMessage({"code": "en-US", "content": "Now"})
+@Alias({"code": "en-US", "content": "now;current;today;current date;current time;date;time;std"})
+@DisplayIcon("tabler:calendar")
+class StdDateNow(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdDateNow.run() is not implemented")

hercules/definitions/taurus_file/data_types/file.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict
+
+
+class File(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    contentType: Any
+    fileName: str
+    valueType: Literal['base64']
+    value: str
+
+
+from hercules.internal.schema import register_schema
+register_schema(File, "FILE")

hercules/definitions/taurus_file/runtime_functions/std_file_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::file::size")
+@Signature("<M extends TEXT>(file: FILE<M>): NUMBER")
+@Name({"code": "en-US", "content": "File Size"})
+@Description({"code": "en-US", "content": "Returns the size of the given file in bytes."})
+@DisplayMessage({"code": "en-US", "content": "Size of ${file}"})
+@Alias({"code": "en-US", "content": "size;file;bytes;length;document;blob;std"})
+@DisplayIcon("tabler:file")
+@Parameter({"runtime_name": "file", "name": [{"code": "en-US", "content": "File"}], "description": [{"code": "en-US", "content": "The file whose size in bytes is to be returned."}]})
+class StdFileSize(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdFileSize.run() is not implemented")

hercules/definitions/taurus_http/data_types/http_auth_place.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class HttpAuthPlace(Enum):
+    Header = 'Header'
+    Url = 'Url'
+
+
+from hercules.internal.schema import register_schema
+register_schema(HttpAuthPlace, "HTTP_AUTH_PLACE")

hercules/definitions/taurus_http/data_types/http_auth_type.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import RootModel
+
+
+class HttpAuthType(
+    RootModel[
+        Literal['Bearer'] | Literal['Basic'] | Literal['X-API-Key'] | str | Any | None
+    ]
+):
+    root: Literal['Bearer'] | Literal['Basic'] | Literal['X-API-Key'] | str | Any | None
+
+
+from hercules.internal.schema import register_schema
+register_schema(HttpAuthType, "HTTP_AUTH_TYPE")

hercules/definitions/taurus_http/data_types/http_auth_value.py

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

hercules/definitions/taurus_http/data_types/http_method.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class HttpMethod(Enum):
+    GET = 'GET'
+    POST = 'POST'
+    PUT = 'PUT'
+    DELETE = 'DELETE'
+    PATCH = 'PATCH'
+    HEAD = 'HEAD'
+
+
+from hercules.internal.schema import register_schema
+register_schema(HttpMethod, "HTTP_METHOD")

hercules/definitions/taurus_http/data_types/http_payload.py

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

hercules/definitions/taurus_http/data_types/http_request.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class HttpRequest(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    http_method: Any
+    url: Any
+    payload: Any
+    headers: Any
+
+
+from hercules.internal.schema import register_schema
+register_schema(HttpRequest, "HTTP_REQUEST")

hercules/definitions/taurus_http/data_types/http_response.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class HttpResponse(BaseModel):
+    model_config = ConfigDict(
+        extra='forbid',
+    )
+    payload: Any
+    headers: Any
+    http_status_code: Any
+
+
+from hercules.internal.schema import register_schema
+register_schema(HttpResponse, "HTTP_RESPONSE")

hercules/definitions/taurus_http/data_types/http_schema.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import RootModel
+
+
+class HttpSchema(
+    RootModel[
+        Literal['application/json']
+        | Literal['application/xml']
+        | Literal['text/plain']
+        | Literal['text/csv']
+        | str
+        | Any
+        | None
+    ]
+):
+    root: (
+        Literal['application/json']
+        | Literal['application/xml']
+        | Literal['text/plain']
+        | Literal['text/csv']
+        | str
+        | Any
+        | None
+    )
+
+
+from hercules.internal.schema import register_schema
+register_schema(HttpSchema, "HTTP_SCHEMA")

hercules/definitions/taurus_http/data_types/http_status_code.py

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

hercules/definitions/taurus_http/data_types/http_url.py

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

hercules/definitions/taurus_http/runtime_functions/http_request_send.py

@@ -0,0 +1,26 @@
+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("http::request::send")
+@Signature("<A extends HTTP_AUTH_TYPE, S extends HTTP_SCHEMA>(http_method: HTTP_METHOD, url: HTTP_URL, http_auth: A, http_auth_value: HTTP_AUTH_VALUE<A>, http_auth_place: HTTP_AUTH_PLACE<A>, http_schema: S, payload: HTTP_PAYLOAD<S>, headers?: OBJECT<{}>): HTTP_RESPONSE<any>")
+@Name({"code": "en-US", "content": "Send HTTP request"})
+@Description({"code": "en-US", "content": "Sends a request to the specified url with the given method, headers and payload, and returns the response as an HTTP_RESPONSE object. This function initiates an HTTP request to a specified endpoint, allowing you to interact with web services or APIs by sending data and receiving responses."})
+@DisplayMessage({"code": "en-US", "content": "Send request to ${url} with ${payload}"})
+@Alias({"code": "en-US", "content": "send;sends;execute;request;http"})
+@DisplayIcon("tabler:world-www")
+@ThrowsError()
+@Parameter({"runtime_name": "http_method", "name": [{"code": "en-US", "content": "HTTP Method"}], "description": [{"code": "en-US", "content": "Defines the HTTP method to be used, such as GET, POST, PUT, or DELETE."}]})
+@Parameter({"runtime_name": "url", "name": [{"code": "en-US", "content": "Request URL"}], "description": [{"code": "en-US", "content": "Specifies the endpoint address, including protocol, host, path, and query parameters, where the request is directed."}]})
+@Parameter({"runtime_name": "http_auth", "name": [{"code": "en-US", "content": "Auth Type"}], "description": [{"code": "en-US", "content": "Specifies the authentication variant to use, such as Bearer, Basic, X-API-Key, or a custom scheme. Use undefined to send the request without authentication."}]})
+@Parameter({"runtime_name": "http_auth_value", "name": [{"code": "en-US", "content": "Auth Value"}], "description": [{"code": "en-US", "content": "Provides the credentials for the selected authentication type. For Basic auth, supply an object with username and password; for all other types, provide a token or key string."}]})
+@Parameter({"runtime_name": "http_auth_place", "name": [{"code": "en-US", "content": "Auth Placement"}], "description": [{"code": "en-US", "content": "Defines where the authentication credentials are attached to the request. Bearer and Basic auth always use Header; custom schemes can be placed in the Header or as a URL query parameter."}]})
+@Parameter({"runtime_name": "http_schema", "name": [{"code": "en-US", "content": "Content Type"}], "description": [{"code": "en-US", "content": "Specifies the MIME type of the request payload, such as application/json, application/xml, or text/plain. This determines the expected format of the payload parameter."}]})
+@Parameter({"runtime_name": "payload", "name": [{"code": "en-US", "content": "Request Payload"}], "description": [{"code": "en-US", "content": "Contains the request payload. For application/json the value must be an OBJECT, for all other content types a plain string is expected."}]})
+@Parameter({"runtime_name": "headers", "name": [{"code": "en-US", "content": "HTTP Headers"}], "description": [{"code": "en-US", "content": "An optional collection of key-value pairs containing additional request metadata such as custom headers."}]})
+class HttpRequestSend(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("HttpRequestSend.run() is not implemented")

hercules/definitions/taurus_list/data_types/list.py

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

hercules/definitions/taurus_list/runtime_functions/std_list_at.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::list::at")
+@Signature("<T>(list: LIST<T>, index: NUMBER): T")
+@Name({"code": "en-US", "content": "Get Element of List"})
+@Description({"code": "en-US", "content": "Retrieves the element at a specified index from a list."})
+@DisplayMessage({"code": "en-US", "content": "Get element at ${index} of ${list}"})
+@Alias({"code": "en-US", "content": "at;array;list;collection;std;index"})
+@DisplayIcon("tabler:list")
+@ThrowsError()
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "Input List"}], "description": [{"code": "en-US", "content": "The list from which to retrieve an element."}]})
+@Parameter({"runtime_name": "index", "name": [{"code": "en-US", "content": "Index"}], "description": [{"code": "en-US", "content": "The zero-based index of the element to retrieve."}]})
+class StdListAt(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListAt.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_concat.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::list::concat")
+@Signature("<T>(first: LIST<T>, second: LIST<T>): LIST<T>")
+@Name({"code": "en-US", "content": "Combine Lists"})
+@Description({"code": "en-US", "content": "Concatenates/combine two lists into a single list."})
+@DisplayMessage({"code": "en-US", "content": "Combine ${first} with ${second}"})
+@Alias({"code": "en-US", "content": "concat;combine;join;append;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@ThrowsError()
+@Parameter({"runtime_name": "first", "name": [{"code": "en-US", "content": "First List"}], "description": [{"code": "en-US", "content": "The first list to concatenate."}]})
+@Parameter({"runtime_name": "second", "name": [{"code": "en-US", "content": "Second List"}], "description": [{"code": "en-US", "content": "The second list to concatenate."}]})
+class StdListConcat(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListConcat.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_filter.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::filter")
+@Signature("<T>(list: LIST<T>, predicate: PREDICATE<T>): LIST<T>")
+@Name({"code": "en-US", "content": "Filter List"})
+@Description({"code": "en-US", "content": "Returns a new list containing only the elements from the input list for which the predicate returns true."})
+@DisplayMessage({"code": "en-US", "content": "Filter elements in ${list} matching ${predicate}"})
+@Alias({"code": "en-US", "content": "filter;array;list;collection;std"})
+@DisplayIcon("tabler:arrow-iteration")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "Input List"}], "description": [{"code": "en-US", "content": "The list to be filtered."}]})
+@Parameter({"runtime_name": "predicate", "name": [{"code": "en-US", "content": "Filter Predicate"}], "description": [{"code": "en-US", "content": "A function that takes an element of the list and returns a boolean indicating whether the element should be included in the output list."}]})
+class StdListFilter(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListFilter.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_find.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::list::find")
+@Signature("<T>(list: LIST<T>, predicate: PREDICATE<T>): T")
+@Name({"code": "en-US", "content": "Find Element in List"})
+@Description({"code": "en-US", "content": "Returns the first element from the input list for which the predicate returns true. If no element matches, returns null."})
+@DisplayMessage({"code": "en-US", "content": "Find first element in ${list} matching ${predicate}"})
+@Alias({"code": "en-US", "content": "find;array;list;collection;std"})
+@DisplayIcon("tabler:arrow-iteration")
+@ThrowsError()
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "Input List"}], "description": [{"code": "en-US", "content": "The list in which an element satisfying the predicate will be searched."}]})
+@Parameter({"runtime_name": "predicate", "name": [{"code": "en-US", "content": "Search Predicate"}], "description": [{"code": "en-US", "content": "A function that takes an element of the list and returns a boolean indicating if the element matches the search criteria."}]})
+class StdListFind(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListFind.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_find_index.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::find_index")
+@Signature("<T>(list: LIST<T>, predicate: PREDICATE<T>): NUMBER")
+@Name({"code": "en-US", "content": "Find Index of Element in List"})
+@Description({"code": "en-US", "content": "Returns the zero-based index of the first element for which the predicate returns true. If no element matches, returns -1."})
+@DisplayMessage({"code": "en-US", "content": "Index of Element in ${list} matching ${predicate}"})
+@Alias({"code": "en-US", "content": "find index;index of;position;array;list;collection;std;find;index"})
+@DisplayIcon("tabler:arrow-iteration")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "Input List"}], "description": [{"code": "en-US", "content": "The list in which to find the index of an element that satisfies the predicate."}]})
+@Parameter({"runtime_name": "predicate", "name": [{"code": "en-US", "content": "Search Predicate"}], "description": [{"code": "en-US", "content": "A function that takes an element of the list and returns a boolean indicating if the element satisfies the search criteria."}]})
+class StdListFindIndex(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListFindIndex.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_find_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 ThrowsError, Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("std::list::find_last")
+@Signature("<T>(list: LIST<T>, predicate: PREDICATE<T>): T")
+@Name({"code": "en-US", "content": "Find Last Element in List"})
+@Description({"code": "en-US", "content": "Returns the last element from the input list for which the predicate returns true. If no element matches, returns null or equivalent."})
+@DisplayMessage({"code": "en-US", "content": "Last Element of ${list} matching ${predicate}"})
+@Alias({"code": "en-US", "content": "find last;last index;last position;array;list;collection;std;find;last"})
+@DisplayIcon("tabler:arrow-iteration")
+@ThrowsError()
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "Input List"}], "description": [{"code": "en-US", "content": "The list in which an element satisfying the predicate will be searched."}]})
+@Parameter({"runtime_name": "predicate", "name": [{"code": "en-US", "content": "Search Predicate"}], "description": [{"code": "en-US", "content": "A function that takes an element of the list and returns a boolean indicating if the element matches the search criteria."}]})
+class StdListFindLast(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListFindLast.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_first.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::first")
+@Signature("<T>(list: LIST<T>): T")
+@Name({"code": "en-US", "content": "First Element of List"})
+@Description({"code": "en-US", "content": "Retrieves the first element from the list."})
+@DisplayMessage({"code": "en-US", "content": "Get First Element in ${list}"})
+@Alias({"code": "en-US", "content": "first;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "Input List"}], "description": [{"code": "en-US", "content": "The list from which to retrieve the first element."}]})
+class StdListFirst(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListFirst.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_flat.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::flat")
+@Signature("<T>(list: LIST<LIST<T>>): LIST<T>")
+@Name({"code": "en-US", "content": "Flatten List"})
+@Description({"code": "en-US", "content": "Flattens a nested list into a single-level list."})
+@DisplayMessage({"code": "en-US", "content": "Flatten ${list}"})
+@Alias({"code": "en-US", "content": "flat;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "Nested List"}], "description": [{"code": "en-US", "content": "A list containing sub-lists that will be flattened into a single-level list."}]})
+class StdListFlat(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListFlat.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_for_each.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::for_each")
+@Signature("<T>(list: LIST<T>, consumer: CONSUMER<T>): void")
+@Name({"code": "en-US", "content": "For Each Element"})
+@Description({"code": "en-US", "content": "Executes a consumer function for each element in the list."})
+@DisplayMessage({"code": "en-US", "content": "For each in ${list} do ${consumer}"})
+@Alias({"code": "en-US", "content": "for_each;array;list;collection;std;for;each"})
+@DisplayIcon("tabler:arrow-iteration")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "Input List"}], "description": [{"code": "en-US", "content": "Each element of this list will be passed to the provided consumer function for processing."}]})
+@Parameter({"runtime_name": "consumer", "name": [{"code": "en-US", "content": "Consumer Function"}], "description": [{"code": "en-US", "content": "This function is invoked once for each element in the list. It is not expected to return a value."}]})
+class StdListForEach(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListForEach.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_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::list::index_of")
+@Signature("<T>(list: LIST<T>, item: T): NUMBER")
+@Name({"code": "en-US", "content": "Index of Item"})
+@Description({"code": "en-US", "content": "Returns the zero-based index of the first occurrence of a given item in the specified list. If the item is not found, it typically returns -1."})
+@DisplayMessage({"code": "en-US", "content": "Get Index of ${item} in ${list}"})
+@Alias({"code": "en-US", "content": "index_of;array;list;collection;std;index;of"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "List"}], "description": [{"code": "en-US", "content": "A list of elements in which the specified item will be searched for to determine its index."}]})
+@Parameter({"runtime_name": "item", "name": [{"code": "en-US", "content": "Item"}], "description": [{"code": "en-US", "content": "The item for which the function searches in the list and returns the index of its first occurrence."}]})
+class StdListIndexOf(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListIndexOf.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_is_empty.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::is_empty")
+@Signature("<T>(list: LIST<T>): BOOLEAN")
+@Name({"code": "en-US", "content": "Is List Empty"})
+@Description({"code": "en-US", "content": "Returns true if the list contains no elements, otherwise returns false."})
+@DisplayMessage({"code": "en-US", "content": "Check if ${list} is empty"})
+@Alias({"code": "en-US", "content": "is_empty;array;list;collection;std;is;empty"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "List"}], "description": [{"code": "en-US", "content": "The list to check for emptiness."}]})
+class StdListIsEmpty(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListIsEmpty.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_join.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::join")
+@Signature("(list: LIST<TEXT>, join_text: TEXT): TEXT")
+@Name({"code": "en-US", "content": "Join Text List"})
+@Description({"code": "en-US", "content": "Returns a single concatenated string of text joined by the provided join text."})
+@DisplayMessage({"code": "en-US", "content": "Joins ${list} using '${join_text}'"})
+@Alias({"code": "en-US", "content": "join;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "List of Text"}], "description": [{"code": "en-US", "content": "A list of text elements to combined into a single word."}]})
+@Parameter({"runtime_name": "join_text", "name": [{"code": "en-US", "content": "Join Text"}], "description": [{"code": "en-US", "content": "The text that will be used to join the list elements into a single string."}]})
+class StdListJoin(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListJoin.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_last.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::last")
+@Signature("<T>(list: LIST<T>): T")
+@Name({"code": "en-US", "content": "Last Element of List"})
+@Description({"code": "en-US", "content": "Retrieves the last element from the list."})
+@DisplayMessage({"code": "en-US", "content": "Get Last Element of ${list}"})
+@Alias({"code": "en-US", "content": "last;array;list;collection;std"})
+@DisplayIcon("tabler:list")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "Input List"}], "description": [{"code": "en-US", "content": "The list from which to retrieve the last element."}]})
+class StdListLast(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListLast.run() is not implemented")

hercules/definitions/taurus_list/runtime_functions/std_list_map.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::map")
+@Signature("<T, R>(list: LIST<T>, transform: TRANSFORM<T, R>): LIST<R>")
+@Name({"code": "en-US", "content": "Map List"})
+@Description({"code": "en-US", "content": "Transforms each element in the list using the provided function. This will create a new list of new elements which will be returned."})
+@DisplayMessage({"code": "en-US", "content": "Apply ${transform} for each in ${list}"})
+@Alias({"code": "en-US", "content": "map;array;list;collection;std"})
+@DisplayIcon("tabler:arrow-iteration")
+@Parameter({"runtime_name": "list", "name": [{"code": "en-US", "content": "Input List"}], "description": [{"code": "en-US", "content": "Each element of this list will be passed through the transform function."}]})
+@Parameter({"runtime_name": "transform", "name": [{"code": "en-US", "content": "Transform Function"}], "description": [{"code": "en-US", "content": "The transform function is applied to every element of the list to produce a new list."}]})
+class StdListMap(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("StdListMap.run() is not implemented")