code0-hercules 1.3.0__py3-none-any.whl

hercules/decorators/datatype.py

@@ -0,0 +1,39 @@
+"""Data type decorators (port of ``src/decorators/datatype.dec.ts``)."""
+from __future__ import annotations
+
+from typing import Type
+
+from pydantic import BaseModel
+
+from hercules._metadata import define_metadata
+
+
+def Schema_(schema: Type[BaseModel]):
+    """Attach the Pydantic model that describes a data type's shape."""
+
+    def decorator(target):
+        define_metadata("hercules:schema", schema, target)
+        return target
+
+    return decorator
+
+
+def TypeString(type_string: str):
+    """Emit an explicit TypeScript type string for a data type, verbatim.
+
+    Used by the generated built-in definitions to preserve cross-data-type
+    identifier references exactly. User-authored data types normally omit this
+    and let the type be derived from the ``@Schema`` Pydantic model.
+    """
+
+    def decorator(target):
+        define_metadata("hercules:type_string", type_string, target)
+        return target
+
+    return decorator
+
+
+# Exported under the name ``Schema`` to match the TypeScript decorator.
+Schema = Schema_  # type: ignore[assignment]
+
+__all__ = ["Schema", "TypeString"]

hercules/decorators/event.py

@@ -0,0 +1,35 @@
+"""Event decorators (port of ``src/decorators/event.dec.ts``)."""
+from __future__ import annotations
+
+from typing import Union
+
+from hercules._metadata import define_metadata, get_own_metadata
+from hercules.decorators.meta import normalize_translations
+from hercules.models.event import EventSettingProps
+
+
+def _coerce_setting(setting: Union[EventSettingProps, dict]) -> EventSettingProps:
+    if isinstance(setting, EventSettingProps):
+        return setting
+    data = dict(setting)
+    for key in ("name", "description"):
+        if data.get(key) is not None:
+            data[key] = normalize_translations(data[key])
+    return EventSettingProps(**data)
+
+
+def EventSetting(setting: Union[EventSettingProps, dict]):
+    coerced = _coerce_setting(setting)
+
+    def decorator(target):
+        # get_own_metadata: getMetadata would return the parent class's array on
+        # subclasses, and inserting would mutate the parent's settings.
+        settings = get_own_metadata("hercules:flow_settings", target) or []
+        settings.insert(0, coerced)
+        define_metadata("hercules:flow_settings", settings, target)
+        return target
+
+    return decorator
+
+
+__all__ = ["EventSetting"]

hercules/decorators/function.py

@@ -0,0 +1,59 @@
+"""Function decorators (port of ``src/decorators/function.dec.ts``)."""
+from __future__ import annotations
+
+from typing import Union
+
+from hercules._metadata import define_metadata, get_own_metadata
+from hercules.decorators.meta import normalize_translations
+from hercules.models.function import FunctionParameterProps
+
+
+def OmitFunction():
+    def decorator(target):
+        define_metadata("hercules:omit_function_definition", True, target)
+        return target
+
+    return decorator
+
+
+def Design(design: str):
+    def decorator(target):
+        define_metadata("hercules:design", design, target)
+        return target
+
+    return decorator
+
+
+def ThrowsError(throws_error: bool = True):
+    def decorator(target):
+        define_metadata("hercules:throws_error", throws_error, target)
+        return target
+
+    return decorator
+
+
+def _coerce_parameter(parameter: Union[FunctionParameterProps, dict]) -> FunctionParameterProps:
+    if isinstance(parameter, FunctionParameterProps):
+        return parameter
+    param = dict(parameter)
+    for key in ("name", "description", "documentation"):
+        if param.get(key) is not None:
+            param[key] = normalize_translations(param[key])
+    return FunctionParameterProps(**param)
+
+
+def Parameter(parameter: Union[FunctionParameterProps, dict]):
+    coerced = _coerce_parameter(parameter)
+
+    def decorator(target):
+        # get_own_metadata: getMetadata would return the parent class's array on
+        # subclasses, and inserting would mutate the parent's parameters.
+        parameters = get_own_metadata("hercules:function_parameters", target) or []
+        parameters.insert(0, coerced)
+        define_metadata("hercules:function_parameters", parameters, target)
+        return target
+
+    return decorator
+
+
+__all__ = ["OmitFunction", "Design", "ThrowsError", "Parameter"]

hercules/decorators/meta.py

@@ -0,0 +1,82 @@
+"""Meta decorators (port of ``src/decorators/meta.dec.ts``).
+
+Each decorator attaches class metadata under a ``hercules:*`` key, mirroring the
+TypeScript ``reflect-metadata`` usage. Translation arguments accept either
+:class:`~hercules.types.Translation` instances or ``{"code", "content"}`` dicts.
+"""
+from __future__ import annotations
+
+from typing import List, Union
+
+from hercules._metadata import define_metadata
+from hercules.types import Translation
+
+TranslationLike = Union[Translation, dict]
+
+
+def normalize_translations(items) -> List[Translation]:
+    result: List[Translation] = []
+    for item in items:
+        if isinstance(item, Translation):
+            result.append(item)
+        elif isinstance(item, dict):
+            result.append(Translation(code=item["code"], content=item["content"]))
+        else:
+            raise TypeError(f"Invalid translation: {item!r}")
+    return result
+
+
+def _meta(key: str):
+    def decorator_factory(*translations: TranslationLike):
+        normalized = normalize_translations(translations)
+
+        def decorator(target):
+            define_metadata(key, normalized, target)
+            return target
+
+        return decorator
+
+    return decorator_factory
+
+
+Identifier = lambda id: _define_simple("hercules:identifier", id)  # noqa: E731
+Signature = lambda signature: _define_simple("hercules:signature", signature)  # noqa: E731
+DisplayIcon = lambda display_icon: _define_simple("hercules:display_icon", display_icon)  # noqa: E731
+
+
+def _define_simple(key: str, value):
+    def decorator(target):
+        define_metadata(key, value, target)
+        return target
+
+    return decorator
+
+
+def Editable(editable: bool = True):
+    def decorator(target):
+        define_metadata("hercules:editable", editable, target)
+        return target
+
+    return decorator
+
+
+Name = _meta("hercules:name")
+Description = _meta("hercules:description")
+Documentation = _meta("hercules:documentation")
+DisplayMessage = _meta("hercules:display_message")
+Alias = _meta("hercules:alias")
+DeprecationMessage = _meta("hercules:deprecation_message")
+
+__all__ = [
+    "Identifier",
+    "Name",
+    "Description",
+    "Documentation",
+    "DisplayMessage",
+    "Alias",
+    "DeprecationMessage",
+    "Signature",
+    "DisplayIcon",
+    "Editable",
+    "normalize_translations",
+]

hercules/decorators/runtime_event.py

@@ -0,0 +1,15 @@
+"""Runtime event decorators (port of ``src/decorators/runtime_event.dec.ts``)."""
+from __future__ import annotations
+
+from hercules._metadata import define_metadata
+
+
+def OmitEvent():
+    def decorator(target):
+        define_metadata("hercules:omit_event_definition", True, target)
+        return target
+
+    return decorator
+
+
+__all__ = ["OmitEvent"]

hercules/decorators/runtime_function.py

@@ -0,0 +1,18 @@
+"""Runtime function decorators.
+
+Port of ``src/decorators/runtime_function.dec.ts``.
+"""
+from __future__ import annotations
+
+from hercules._metadata import define_metadata
+
+
+def OmitRuntimeFunction():
+    def decorator(target):
+        define_metadata("hercules:omit_function_definition", True, target)
+        return target
+
+    return decorator
+
+
+__all__ = ["OmitRuntimeFunction"]

hercules/definitions/__init__.py

@@ -0,0 +1,162 @@
+import hercules.definitions.cron_action.data_types.cron_day_of_month  # noqa: F401
+import hercules.definitions.cron_action.data_types.cron_day_of_week  # noqa: F401
+import hercules.definitions.cron_action.data_types.cron_hour  # noqa: F401
+import hercules.definitions.cron_action.data_types.cron_minute  # noqa: F401
+import hercules.definitions.cron_action.data_types.cron_month  # noqa: F401
+import hercules.definitions.cron_action.runtime_flow_types.cron  # noqa: F401
+import hercules.definitions.rest_action.data_types.rest_adapter_input  # noqa: F401
+import hercules.definitions.rest_action.data_types.rest_auth_type  # noqa: F401
+import hercules.definitions.rest_action.data_types.rest_auth_value  # noqa: F401
+import hercules.definitions.rest_action.runtime_flow_types.rest  # noqa: F401
+import hercules.definitions.rest_action.runtime_functions.rest_control_respond  # noqa: F401
+import hercules.definitions.taurus_boolean.data_types.boolean  # noqa: F401
+import hercules.definitions.taurus_boolean.runtime_functions.std_boolean_as_number  # noqa: F401
+import hercules.definitions.taurus_boolean.runtime_functions.std_boolean_as_text  # noqa: F401
+import hercules.definitions.taurus_boolean.runtime_functions.std_boolean_from_number  # noqa: F401
+import hercules.definitions.taurus_boolean.runtime_functions.std_boolean_from_text  # noqa: F401
+import hercules.definitions.taurus_boolean.runtime_functions.std_boolean_is_equal  # noqa: F401
+import hercules.definitions.taurus_boolean.runtime_functions.std_boolean_negate  # noqa: F401
+import hercules.definitions.taurus_color.data_types.color  # noqa: F401
+import hercules.definitions.taurus_color.runtime_functions.std_color_as_hex  # noqa: F401
+import hercules.definitions.taurus_color.runtime_functions.std_color_as_hsl  # noqa: F401
+import hercules.definitions.taurus_color.runtime_functions.std_color_as_rgb  # noqa: F401
+import hercules.definitions.taurus_color.runtime_functions.std_color_from_hex  # noqa: F401
+import hercules.definitions.taurus_color.runtime_functions.std_color_from_hsl  # noqa: F401
+import hercules.definitions.taurus_color.runtime_functions.std_color_from_rgb  # noqa: F401
+import hercules.definitions.taurus_control.data_types.comparator  # noqa: F401
+import hercules.definitions.taurus_control.data_types.consumer  # noqa: F401
+import hercules.definitions.taurus_control.data_types.predicate  # noqa: F401
+import hercules.definitions.taurus_control.data_types.runnable  # noqa: F401
+import hercules.definitions.taurus_control.data_types.transform  # noqa: F401
+import hercules.definitions.taurus_control.runtime_functions.std_control_if  # noqa: F401
+import hercules.definitions.taurus_control.runtime_functions.std_control_if_else  # noqa: F401
+import hercules.definitions.taurus_control.runtime_functions.std_control_return  # noqa: F401
+import hercules.definitions.taurus_control.runtime_functions.std_control_stop  # noqa: F401
+import hercules.definitions.taurus_control.runtime_functions.std_control_value  # noqa: F401
+import hercules.definitions.taurus_date.data_types.date  # noqa: F401
+import hercules.definitions.taurus_date.data_types.hour  # noqa: F401
+import hercules.definitions.taurus_date.data_types.minute  # noqa: F401
+import hercules.definitions.taurus_date.data_types.month  # noqa: F401
+import hercules.definitions.taurus_date.runtime_functions.std_date_format  # noqa: F401
+import hercules.definitions.taurus_date.runtime_functions.std_date_from  # noqa: F401
+import hercules.definitions.taurus_date.runtime_functions.std_date_from_text  # noqa: F401
+import hercules.definitions.taurus_date.runtime_functions.std_date_from_unix  # noqa: F401
+import hercules.definitions.taurus_date.runtime_functions.std_date_now  # noqa: F401
+import hercules.definitions.taurus_file.data_types.file  # noqa: F401
+import hercules.definitions.taurus_file.runtime_functions.std_file_size  # noqa: F401
+import hercules.definitions.taurus_http.data_types.http_auth_place  # noqa: F401
+import hercules.definitions.taurus_http.data_types.http_auth_type  # noqa: F401
+import hercules.definitions.taurus_http.data_types.http_auth_value  # noqa: F401
+import hercules.definitions.taurus_http.data_types.http_method  # noqa: F401
+import hercules.definitions.taurus_http.data_types.http_payload  # noqa: F401
+import hercules.definitions.taurus_http.data_types.http_request  # noqa: F401
+import hercules.definitions.taurus_http.data_types.http_response  # noqa: F401
+import hercules.definitions.taurus_http.data_types.http_schema  # noqa: F401
+import hercules.definitions.taurus_http.data_types.http_status_code  # noqa: F401
+import hercules.definitions.taurus_http.data_types.http_url  # noqa: F401
+import hercules.definitions.taurus_http.runtime_functions.http_request_send  # noqa: F401
+import hercules.definitions.taurus_list.data_types.list  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_at  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_concat  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_filter  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_find  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_find_index  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_find_last  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_first  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_flat  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_for_each  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_index_of  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_is_empty  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_join  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_last  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_map  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_max  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_min  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_pop  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_push  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_remove  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_reverse  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_size  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_sort  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_sort_reverse  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_sum  # noqa: F401
+import hercules.definitions.taurus_list.runtime_functions.std_list_to_unique  # noqa: F401
+import hercules.definitions.taurus_number.data_types.number  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_abs  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_add  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_arccos  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_arcsin  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_arctan  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_as_text  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_clamp  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_cos  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_cosh  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_divide  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_euler  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_exponential  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_from_text  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_has_digits  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_is_equal  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_is_greater  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_is_less  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_is_positive  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_is_zero  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_ln  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_log  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_max  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_min  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_modulo  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_multiply  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_negate  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_pi  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_random_number  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_remove_digits  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_root  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_round  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_round_down  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_round_up  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_sin  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_sinh  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_square  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_square_root  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_subtract  # noqa: F401
+import hercules.definitions.taurus_number.runtime_functions.std_number_tan  # noqa: F401
+import hercules.definitions.taurus_object.data_types.object  # noqa: F401
+import hercules.definitions.taurus_object.data_types.type  # noqa: F401
+import hercules.definitions.taurus_object.runtime_functions.std_object_contains_key  # noqa: F401
+import hercules.definitions.taurus_object.runtime_functions.std_object_get  # noqa: F401
+import hercules.definitions.taurus_object.runtime_functions.std_object_keys  # noqa: F401
+import hercules.definitions.taurus_object.runtime_functions.std_object_set  # noqa: F401
+import hercules.definitions.taurus_object.runtime_functions.std_object_size  # noqa: F401
+import hercules.definitions.taurus_text.data_types.text  # noqa: F401
+import hercules.definitions.taurus_text.data_types.text_encoding  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_append  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_as_bytes  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_at  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_byte_size  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_capitalize  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_chars  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_contains  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_decode  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_encode  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_ends_with  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_from_ascii  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_hex  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_index_of  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_insert  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_is_equal  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_length  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_lowercase  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_octal  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_prepend  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_remove  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_replace  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_replace_first  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_replace_last  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_reverse  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_split  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_starts_with  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_swapcase  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_to_ascii  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_trim  # noqa: F401
+import hercules.definitions.taurus_text.runtime_functions.std_text_uppercase  # noqa: F401

hercules/definitions/cron_action/data_types/cron_day_of_month.py

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

hercules/definitions/cron_action/data_types/cron_day_of_week.py

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

hercules/definitions/cron_action/data_types/cron_hour.py

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

hercules/definitions/cron_action/data_types/cron_minute.py

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

hercules/definitions/cron_action/data_types/cron_month.py

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

hercules/definitions/cron_action/runtime_flow_types/cron.py

@@ -0,0 +1,19 @@
+from hercules.models.runtime_event import RuntimeEventRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.event import EventSetting
+
+
+@Identifier("CRON")
+@Signature("(cron_minute: CRON_MINUTE, cron_hour: CRON_HOUR, cron_day_of_month: CRON_DAY_OF_MONTH, cron_month: CRON_MONTH, cron_day_of_week: CRON_DAY_OF_WEEK): void")
+@Name({"code": "en-US", "content": "Cron Job"})
+@Description({"code": "en-US", "content": "A Cron Job is a scheduled task that runs automatically at specified intervals, typically defined using cron expressions. It is commonly used to automate repetitive operations such as data processing, system maintenance, and periodic updates without requiring manual execution."})
+@DisplayMessage({"code": "en-US", "content": "Runs flow every ${cron_minute}min ${cron_hour}hour ${cron_day_of_month}day of month ${cron_month}month ${cron_day_of_week}day of week"})
+@Alias({"code": "en-US", "content": "cron;code;schedule;timer;clock;flow"})
+@DisplayIcon("tabler:file-time")
+@EventSetting({"identifier": "cron_minute", "name": [{"code": "en-US", "content": "Minute"}], "description": [{"code": "en-US", "content": "Defines the minute when the flow runs (e.g., 0 for on the hour, */5 for every 5 minutes)."}]})
+@EventSetting({"identifier": "cron_hour", "name": [{"code": "en-US", "content": "Hour"}], "description": [{"code": "en-US", "content": "Defines the hour when the flow runs (e.g., 0 for midnight, 14 for 2 PM)."}]})
+@EventSetting({"identifier": "cron_day_of_month", "name": [{"code": "en-US", "content": "Day of the Month"}], "description": [{"code": "en-US", "content": "Defines the day of the month when the flow runs (e.g., 1 for first day, 15 for mid-month)."}]})
+@EventSetting({"identifier": "cron_month", "name": [{"code": "en-US", "content": "Month"}], "description": [{"code": "en-US", "content": "Defines the month when the flow runs (e.g., 1 for January, 12 for December)."}]})
+@EventSetting({"identifier": "cron_day_of_week", "name": [{"code": "en-US", "content": "Day of the Week"}], "description": [{"code": "en-US", "content": "Defines the weekday when the flow runs (e.g., 0 or SUN for Sunday, MON-FRI for weekdays)."}]})
+class Cron(RuntimeEventRunnable):
+    pass

hercules/definitions/rest_action/data_types/rest_adapter_input.py

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

hercules/definitions/rest_action/data_types/rest_auth_type.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import RootModel
+
+
+class RestAuthType(
+    RootModel[
+        Literal['Bearer JWT'] | Literal['Bearer static'] | Literal['Basic'] | Any | None
+    ]
+):
+    root: (
+        Literal['Bearer JWT'] | Literal['Bearer static'] | Literal['Basic'] | Any | None
+    )
+
+
+from hercules.internal.schema import register_schema
+register_schema(RestAuthType, "REST_AUTH_TYPE")

hercules/definitions/rest_action/data_types/rest_auth_value.py

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

hercules/definitions/rest_action/runtime_flow_types/rest.py

@@ -0,0 +1,20 @@
+from hercules.models.runtime_event import RuntimeEventRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.event import EventSetting
+
+
+@Identifier("REST")
+@Signature("<A extends REST_AUTH_TYPE, T>(http_schema: HTTP_SCHEMA, http_url: HTTP_URL, http_method: HTTP_METHOD, http_auth: A, http_auth_value: REST_AUTH_VALUE<A>, input_schema: TYPE<T>): REST_ADAPTER_INPUT<T>")
+@Name({"code": "en-US", "content": "Webhook"})
+@Description({"code": "en-US", "content": "A Webhook is an HTTP endpoint that listens for incoming requests from external services or clients, allowing you to react to events in real time using standard HTTP methods like GET, POST, PUT, and DELETE."})
+@DisplayMessage({"code": "en-US", "content": "Webhook on ${http_method} at ${http_url}"})
+@Alias({"code": "en-US", "content": "webhook;http;rest;route;web"})
+@DisplayIcon("tabler:world-www")
+@EventSetting({"identifier": "http_schema", "name": [{"code": "en-US", "content": "Content Type"}], "description": [{"code": "en-US", "content": "Specifies the MIME type of the incoming request payload, such as application/json, application/xml, or text/plain. This determines the expected format of the payload parameter."}]})
+@EventSetting({"identifier": "http_url", "unique": "PROJECT", "name": [{"code": "en-US", "content": "URL"}], "description": [{"code": "en-US", "content": "Specifies the HTTP URL endpoint."}]})
+@EventSetting({"identifier": "http_method", "name": [{"code": "en-US", "content": "Method"}], "description": [{"code": "en-US", "content": "Specifies the HTTP request method (e.g., GET, POST, PUT, DELETE)."}]})
+@EventSetting({"identifier": "http_auth", "name": [{"code": "en-US", "content": "Authentication type"}], "description": [{"code": "en-US", "content": "Specifies the authentication mechanism used for the incoming Webhook request (e.g., Bearer JWT, Bearer static, Basic)."}], "optional": True})
+@EventSetting({"identifier": "http_auth_value", "name": [{"code": "en-US", "content": "Authentication value"}], "description": [{"code": "en-US", "content": "Provides the credential value matching the selected authentication type (e.g., token string or username/password pair)."}], "optional": True})
+@EventSetting({"identifier": "input_schema", "name": [{"code": "en-US", "content": "Input schema"}], "description": [{"code": "en-US", "content": "Input schema which defines the expected structure of the incoming request data."}], "optional": True})
+class Rest(RuntimeEventRunnable):
+    pass

hercules/definitions/rest_action/runtime_functions/rest_control_respond.py

@@ -0,0 +1,21 @@
+from hercules.models.runtime_function import RuntimeFunctionRunnable
+from hercules.decorators.meta import Alias, Description, DisplayIcon, DisplayMessage, Identifier, Name, Signature
+from hercules.decorators.runtime_function import OmitRuntimeFunction
+from hercules.decorators.function import Parameter
+
+
+@OmitRuntimeFunction()
+@Identifier("rest::control::respond")
+@Signature("<S extends HTTP_SCHEMA>(http_status_code: HTTP_STATUS_CODE, http_schema: S, payload: HTTP_PAYLOAD<S>, headers?: OBJECT<{}>): void")
+@Name({"code": "en-US", "content": "Respond"})
+@Description({"code": "en-US", "content": "Processes an HTTP response and returns it to the requesting client. This function typically completes the HTTP request\u2013response cycle by delivering the server\u2019s final output, such as headers, status codes, and body content, back to the client."})
+@DisplayMessage({"code": "en-US", "content": "Sends response with status ${http_status_code} and payload ${payload}"})
+@Alias({"code": "en-US", "content": "respond;control;http"})
+@DisplayIcon("tabler:cube-send")
+@Parameter({"runtime_name": "http_status_code", "name": [{"code": "en-US", "content": "HTTP Status Code"}], "description": [{"code": "en-US", "content": "An HTTP status code is a three-digit number (100\u2013599) indicating the result of a request (e.g., 200, 404, 500)."}]})
+@Parameter({"runtime_name": "http_schema", "name": [{"code": "en-US", "content": "Content Type"}], "description": [{"code": "en-US", "content": "Specifies the MIME type of the response 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": "Response Payload"}], "description": [{"code": "en-US", "content": "Contains the response 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 response headers"}], "description": [{"code": "en-US", "content": "A collection of key-value pairs containing additional response metadata."}], "optional": True})
+class RestControlRespond(RuntimeFunctionRunnable):
+    def run(self, *args):
+        raise NotImplementedError("RestControlRespond.run() is not implemented")

hercules/definitions/taurus_boolean/data_types/boolean.py

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