kelvin-python-sdk 0.2.0__tar.gz → 0.2.3__tar.gz

{kelvin_python_sdk-0.2.0/kelvin_python_sdk.egg-info → kelvin_python_sdk-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: kelvin-python-sdk
-Version: 0.2.0
+Version: 0.2.3
 Summary: Kelvin Python SDK
 Author-email: Kelvin Inc <engineering@kelvininc.com>
 Classifier: Operating System :: OS Independent
@@ -22,6 +22,7 @@ Requires-Dist: pytest-asyncio; extra == "tests"
 Requires-Dist: pytest-cov; extra == "tests"
 Requires-Dist: time-machine; extra == "tests"
 Requires-Dist: asyncmock; python_version < "3.8" and extra == "tests"
+Requires-Dist: pandas; extra == "tests"
 Provides-Extra: format
 Requires-Dist: isort; extra == "format"
 Requires-Dist: black; extra == "format"

{kelvin_python_sdk-0.2.0 → kelvin_python_sdk-0.2.3}/examples/csv_publisher/csv_publisher.py

@@ -3,36 +3,39 @@ from __future__ import annotations
 import asyncio
 from typing import List, Optional
 
-import yaml
 from pydantic import BaseModel
 
-from kelvin.application import KelvinApp
+from kelvin.application import KelvinApp, Datastream
 from kelvin.krn import KRNAssetDataStream
 from kelvin.logs import logger
-from kelvin.message import Boolean, Message, Number, String
-from kelvin.publisher.publisher import AppConfig, CSVPublisher, MessageData, Metric
-
-
-def message_from_message_data(data: MessageData, outputs: List[Metric]) -> Optional[Message]:
-    output = next((output for output in outputs if output.name == data.resource), None)
+from kelvin.message import Message
+from kelvin.publisher.server import MessageData
+from kelvin.publisher.csv_publisher import CSVPublisher
+from datetime import datetime
+from typing import Any, Type, Union
+
+def string_to_strict_type(value: Any, data_type: Type) -> Union[bool, float, str, dict]:
+    if isinstance(value, data_type):
+        return value
+    if data_type is bool:
+        return str(value).lower() in ["true", "1"]
+    if data_type is float:
+        return float(value)
+    return value
+
+def message_from_message_data(data: MessageData, outputs: List[Datastream]) -> Optional[Message]:
+    output = next((output for output in outputs if output.name == data.resource.data_stream), None)
     if output is None:
         logger.error("csv metric not found in outputs", metric=data.resource)
         return None
-
-    data_type = output.data_type
-    if data_type == "boolean":
-        msg_type = Boolean
-        value = bool(data.value)
-    elif data_type == "number":
-        msg_type = Number
-        value = float(data.value)
-    elif data_type == "string":
-        msg_type = String
-        value = str(data.value)
-    else:
-        return None
-
-    return msg_type(resource=KRNAssetDataStream(data.asset, data.resource), payload=value)
+    
+    msg = Message(
+        type=output.type,
+        timestamp=data.timestamp or datetime.now().astimezone(),
+        resource=data.resource
+    )
+    msg.payload = string_to_strict_type(data.value, type(msg.payload))
+    return msg
 
 
 class AppConfiguration(BaseModel):
@@ -55,7 +58,7 @@ async def main() -> None:
         first_run = False
         async for data in publisher.run():
             for asset in assets:
-                data.asset = asset
+                data.resource = KRNAssetDataStream(asset, data.resource.data_stream)
                 msg = message_from_message_data(data, app.outputs)
                 if msg is not None:
                     await app.publish(msg)

kelvin_python_sdk-0.2.3/examples/custom_action/action_generator.py

@@ -0,0 +1,29 @@
+import asyncio
+from datetime import timedelta
+from typing import AsyncGenerator
+
+from kelvin.message import CustomAction, CustomActionMsg
+from kelvin.publisher import DataGenerator
+
+
+class CustomActionGenerator(DataGenerator):
+    def __init__(self) -> None:
+        print("Hello from MyGenerator")
+
+    async def run(self) -> AsyncGenerator[CustomActionMsg, None]:
+        print("Running MyGenerator")
+
+        for i in range(10):
+            msg = CustomAction(
+                resource="krn:asset:test-asset-1",
+                expiration_date=timedelta(seconds=30),
+                type="example-in",
+                title="hello generator",
+                description="big description",
+                payload={"big": "payload"},
+            )
+
+            print("msg", msg)
+
+            yield msg
+            await asyncio.sleep(1)

kelvin_python_sdk-0.2.3/examples/custom_action/app.yaml

@@ -0,0 +1,16 @@
+# yaml-language-server: $schema=https://apps.kelvininc.com/schemas/kelvin/5.0.0/importer.json
+
+spec_version: 5.0.0
+type: importer
+
+name: custom-action-example
+title: Custom Action Example
+description: Receive and send a custom action
+version: 1.0.0
+
+custom_actions:
+  inputs:
+    - type: example-in
+  outputs:
+    - type: example-out
+    - type: example-out-2

kelvin_python_sdk-0.2.3/examples/custom_action/main.py

@@ -0,0 +1,80 @@
+import asyncio
+from datetime import timedelta
+
+from kelvin.application import KelvinApp
+from kelvin.krn import KRNAsset
+from kelvin.message import CustomAction, Recommendation
+
+
+class CustomActionApp:
+    def __init__(self, app: KelvinApp = KelvinApp()) -> None:
+        self.app = app
+        self.app.on_custom_action = self.on_custom_action
+
+    async def on_custom_action(self, action: CustomAction) -> None:
+        """Callback when a Custom Action is received."""
+        print("Received Custom Action: ", action)
+
+        await self.app.publish(action.result(success=True, message="Custom Action applied"))
+        # OR
+        # await self.app.publish(
+        #     CustomActionAckMsg(
+        #         resource=action.resource,
+        #         payload={
+        #             "id": action._msg.id,
+        #             "success": True,
+        #             "message": "Custom Action applied",
+        #         },
+        #     )
+        # )
+
+    async def publisher_task(self) -> None:
+        i = 0
+        while True:
+            await self.app.publish(
+                CustomAction(
+                    resource=KRNAsset("test-asset-1"),
+                    trace_id=f"trace-{i}",
+                    type="example-out",
+                    title=f"Test Action {i}",
+                    description=f"This is the test action number {i}",
+                    expiration_date=timedelta(seconds=30),
+                    payload={"big": "payload", "action number": i},
+                )
+            )
+
+            await asyncio.sleep(1)
+
+            await self.app.publish(
+                Recommendation(
+                    resource=KRNAsset("test-asset-1"),
+                    type="test-recommendation",
+                    description=f"This is the recommendation number {i}",
+                    expiration_date=timedelta(minutes=5),
+                    trace_id=f"rec-trace-{i}",
+                    actions=[
+                        CustomAction(
+                            resource=KRNAsset("test-asset-1"),
+                            type="example-out-2",
+                            title=f"Test Action {i}",
+                            description=f"This is the test action number {i}",
+                            expiration_date=timedelta(minutes=5),
+                            payload={"big": "payload", "action number": i},
+                        )
+                    ],
+                    auto_accepted=True,
+                )
+            )
+
+            i += 1
+            await asyncio.sleep(5)
+
+    async def run(self) -> None:
+        """Run the app."""
+        await self.app.connect()
+        await self.publisher_task()
+
+
+if __name__ == "__main__":
+    app = CustomActionApp()
+    asyncio.run(app.run())

{kelvin_python_sdk-0.2.0 → kelvin_python_sdk-0.2.3}/kelvin/application/client.py

@@ -16,7 +16,7 @@ from kelvin.krn import KRNAsset, KRNAssetDataStream
 from kelvin.logs import configure_logger, logger
 from kelvin.message import AssetDataMessage, ControlChangeStatus, KMessageType, KMessageTypeData, Message
 from kelvin.message.base_messages import Resource, RuntimeManifest
-from kelvin.message.msg_builders import MessageBuilder
+from kelvin.message.msg_builders import CustomAction, MessageBuilder, convert_message
 
 if TYPE_CHECKING:
     from kelvin.application.window import HoppingWindow, RollingWindow, TumblingWindow
@@ -92,6 +92,8 @@ class KelvinApp:
         """ Callback when a control change is received. """
         self.on_control_status: Optional[Callable[[ControlChangeStatus], Awaitable[None]]] = None
         """ Callback when a control status is received. """
+        self.on_custom_action: Optional[Callable[[CustomAction], Awaitable[None]]] = None
+        """ Callback when a custom action is received. """
 
         self.on_asset_change: Optional[Callable[[Optional[AssetInfo], Optional[AssetInfo]], Awaitable[None]]] = None
         """ Callback when an asset is added, removed or changed.
@@ -294,18 +296,21 @@ class KelvinApp:
             if self.on_app_configuration is not None and self._config_received.is_set():
                 await self.on_app_configuration(self.app_configuration)
 
-        inputs = dict()
-        outputs = dict()
+        inputs = {}
+        outputs = {}
         assets_in_manifest = set()
         for resource in msg.payload.resources:
-            if resource.type != "asset":
+            # check resource is asset
+            if not isinstance(resource.resource, KRNAsset):
                 continue
 
-            assets_in_manifest.add(resource.name)
+            asset_name = resource.resource.asset
 
-            self._last_asset_resources[resource.name] = resource
+            assets_in_manifest.add(asset_name)
+
+            self._last_asset_resources[asset_name] = resource
             asset_info = AssetInfo(
-                name=resource.name, properties=resource.properties, parameters=resource.parameters, datastreams={}
+                name=asset_name, properties=resource.properties, parameters=resource.parameters, datastreams={}
             )
 
             for ds_name, datastream in resource.datastreams.items():
@@ -315,7 +320,7 @@ class KelvinApp:
 
                 name = datastream.map_to if datastream.map_to else ds_name
                 asset_info.datastreams[name] = ResourceDatastream(
-                    asset=KRNAsset(resource.name),  # type: ignore
+                    asset=resource.resource,
                     io_name=name,
                     access=datastream.access,
                     owned=datastream.owned or False,
@@ -334,8 +339,8 @@ class KelvinApp:
                         name=name, type=KMessageTypeData(manif_ds.primitive_type_name)  # type: ignore
                     )
 
-            old_asset_info = self._assets.get(resource.name, None)
-            self._assets[resource.name] = asset_info
+            old_asset_info = self._assets.get(asset_name, None)
+            self._assets[asset_name] = asset_info
 
             if self.on_asset_change is not None and self._config_received.is_set():
                 await self.on_asset_change(asset_info, old_asset_info)
@@ -370,11 +375,17 @@ class KelvinApp:
             await self.on_control_status(msg)  # type: ignore
             return
 
+        if self.on_custom_action is not None and filters.is_custom_action(msg):
+            converted = convert_message(msg)
+            await self.on_custom_action(converted)  # type: ignore
+            return
+
     def _route_to_filters(self, msg: Message) -> None:
         for queue, func in self._filters:
             if func(msg) is True:
+                converted = convert_message(msg) or msg  # convert to message builder
                 # todo: check if the message is reference
-                queue.put_nowait(msg)
+                queue.put_nowait(converted)
 
     def filter(self, func: filters.KelvinFilterType) -> Queue[Message]:
         """Creates a filter for the received Kelvin Messages based on a filter function.

{kelvin_python_sdk-0.2.0 → kelvin_python_sdk-0.2.3}/kelvin/application/filters.py

@@ -6,6 +6,7 @@ from typing_extensions import TypeAlias
 
 from kelvin.krn import KRN, KRNAssetDataStream
 from kelvin.message import ControlChangeStatus, KMessageTypeData, Message
+from kelvin.message.base_messages import CustomActionMsg
 
 KelvinFilterType: TypeAlias = Callable[[Message], bool]
 
@@ -62,3 +63,7 @@ def asset_equals(asset: Union[str, List[str]]) -> KelvinFilterType:
         return msg.resource.asset == asset
 
     return _check
+
+
+def is_custom_action(msg: Message) -> bool:
+    return isinstance(msg, CustomActionMsg)

{kelvin_python_sdk-0.2.0 → kelvin_python_sdk-0.2.3}/kelvin/application/window.py

@@ -1,5 +1,5 @@
 import asyncio
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import AsyncGenerator, Dict, List, Optional, Tuple
 
 from kelvin.message.primitives import AssetDataMessage
@@ -12,6 +12,9 @@ except ImportError as e:
     ) from e
 
 
+UTC = timezone.utc
+
+
 def round_nearest_time(dt: datetime, round_to: Optional[timedelta] = None) -> datetime:
     """
     Rounds the given datetime to the nearest time interval as specified by self.round_to.
@@ -86,7 +89,7 @@ class BaseWindow:
         Initializes the dataframes for the specified assets and datastreams.
         """
         return {
-            asset: pd.DataFrame(columns=self.datastreams, index=pd.DatetimeIndex([], name="timestamp"))
+            asset: pd.DataFrame(columns=self.datastreams, index=pd.DatetimeIndex([], name="timestamp", tz=UTC))
             for asset in self.assets
         }
 
@@ -97,12 +100,16 @@ class BaseWindow:
         Args:
             message (AssetDataMessage): The message to append.
             window_start (Optional[datetime]): The start time of the window to check against.
+                If supplied, it must be timezone-aware.
         """
         asset = message.resource.asset
         datastream = message.resource.data_stream
         value = message.payload
         timestamp = round_nearest_time(message.timestamp, self.round_to)
-        timestamp = timestamp.replace(tzinfo=None)  # Remove timezone information for DataFrame indexing
+        timestamp = timestamp.astimezone(UTC)  # Ensure timestamp is in UTC
+
+        if window_start is not None:
+            window_start = window_start.astimezone(UTC)
 
         if asset not in self.assets:
             # Ignore messages for assets not in the list
@@ -192,16 +199,18 @@ class BaseTimeWindow(BaseWindow):
         """
         Streams data windows continuously by consuming messages and yielding appropriate windows.
 
+        Args:
+            window_start (Optional[datetime]): The start time of the window. Defaults to the current time.
+                If provided, it must be timezone-aware.
+
         Yields:
             AsyncGenerator[Tuple[str, pd.DataFrame], None]: Generator yielding asset and its respective DataFrame.
         """
-        if window_start is None:
-            window_start = datetime.now()
-
+        window_start = datetime.now(UTC) if window_start is None else window_start.astimezone(UTC)
         window_end = window_start + self.hop_size
 
         while True:
-            remaining_time = (window_end - datetime.now()).total_seconds()
+            remaining_time = (window_end - datetime.now(UTC)).total_seconds()
             if remaining_time <= 0:
                 for asset, df in self.dataframes.items():
                     df.sort_index(inplace=True)  # Sort to ensure chronological order

{kelvin_python_sdk-0.2.0 → kelvin_python_sdk-0.2.3}/kelvin/config/common.py

@@ -4,10 +4,10 @@ import json
 import os
 from enum import Enum
 from pathlib import Path
-from typing import Any, Literal, Optional
+from typing import Any, List, Literal, Optional
 
 from pydantic import BaseModel, StringConstraints
-from typing_extensions import Annotated
+from typing_extensions import Annotated, override
 
 NameDNS = Annotated[str, StringConstraints(pattern="^[a-z0-9]([-a-z0-9]*[a-z0-9])?$")]
 VersionStr = Annotated[
@@ -16,6 +16,7 @@ VersionStr = Annotated[
         pattern="^([0-9]+)\\.([0-9]+)\\.([0-9]+)(?:-([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?(?:\\+[0-9A-Za-z-]+)?$"
     ),
 ]
+CustomActionTypeStr = Annotated[str, StringConstraints(pattern="^[a-zA-Z0-9]([-_ .a-zA-Z0-9]*[a-zA-Z0-9])?$")]
 
 
 class ConfigError(Exception):
@@ -25,7 +26,8 @@ class ConfigError(Exception):
 class ConfigBaseModel(BaseModel):
     model_config = {"populate_by_name": True}
 
-    def model_dump(
+    @override
+    def model_dump(  # type: ignore[override]
         self,
         mode: Literal["json", "python"] | str = "json",
         by_alias: bool = True,
@@ -65,6 +67,15 @@ class PrimitiveTypes(str, Enum):
     object = "object"
 
 
+class CustomActionDef(ConfigBaseModel):
+    type: CustomActionTypeStr
+
+
+class CustomActionsIO(ConfigBaseModel):
+    inputs: List[CustomActionDef] = []
+    outputs: List[CustomActionDef] = []
+
+
 class AppBaseConfig(ConfigBaseModel):
     name: NameDNS
     title: str

{kelvin_python_sdk-0.2.0 → kelvin_python_sdk-0.2.3}/kelvin/config/exporter.py

@@ -5,17 +5,19 @@ from typing import Dict, List, Literal, Optional
 
 from pydantic import Field
 
-from kelvin.config.common import AppBaseConfig, AppTypes, ConfigBaseModel, read_schema_file
+from kelvin.config.common import AppBaseConfig, AppTypes, ConfigBaseModel, CustomActionsIO, read_schema_file
 
 from .manifest import (
     AppDefaults,
     AppManifest,
+    CustomActionWay,
     DefaultsDefinition,
     DynamicIODefinition,
     DynamicIoOwnership,
     DynamicIoType,
     Flags,
     IOSchema,
+    ManifCustomAction,
     RuntimeUpdateFlags,
     SchemasDefinition,
 )
@@ -27,6 +29,7 @@ class RuntimeUpdateConfig(ConfigBaseModel):
 
 class ExporterFlags(ConfigBaseModel):
     enable_runtime_update: RuntimeUpdateConfig = RuntimeUpdateConfig()
+    resources_required: Optional[bool] = None
 
 
 class SchemasConfig(ConfigBaseModel):
@@ -52,6 +55,7 @@ class ExporterConfig(AppBaseConfig):
     exporter_io: List[ExporterIO] = []
     ui_schemas: SchemasConfig = SchemasConfig()
     defaults: DeploymentDefaults = DeploymentDefaults()
+    custom_actions: CustomActionsIO = CustomActionsIO()
 
     def to_manifest(self, read_schemas: bool = True, workdir: Path = Path(".")) -> AppManifest:
         return convert_exporter_to_manifest(self, read_schemas=read_schemas, workdir=workdir)
@@ -70,6 +74,10 @@ def convert_exporter_to_manifest(
             for io, schema_path in config.ui_schemas.io_configuration.items()
         ]
 
+    manif_custom_actions = [
+        ManifCustomAction(type=cai.type, way=CustomActionWay.input_ca) for cai in config.custom_actions.inputs
+    ] + [ManifCustomAction(type=cai.type, way=CustomActionWay.output_ca) for cai in config.custom_actions.outputs]
+
     return AppManifest(
         name=config.name,
         title=config.title,
@@ -80,6 +88,7 @@ def convert_exporter_to_manifest(
         flags=Flags(
             spec_version=config.spec_version,
             enable_runtime_update=RuntimeUpdateFlags(configuration=config.flags.enable_runtime_update.configuration),
+            resources_required=config.flags.resources_required,
         ),
         dynamic_io=[
             DynamicIODefinition(
@@ -94,4 +103,5 @@ def convert_exporter_to_manifest(
         defaults=DefaultsDefinition(
             app=AppDefaults(configuration=config.defaults.configuration), system=config.defaults.system
         ),
+        custom_actions=manif_custom_actions,
     )

{kelvin_python_sdk-0.2.0 → kelvin_python_sdk-0.2.3}/kelvin/config/importer.py

@@ -5,17 +5,19 @@ from typing import Dict, List, Literal, Optional
 
 from pydantic import Field
 
-from kelvin.config.common import AppBaseConfig, AppTypes, ConfigBaseModel, read_schema_file
+from kelvin.config.common import AppBaseConfig, AppTypes, ConfigBaseModel, CustomActionsIO, read_schema_file
 
 from .manifest import (
     AppDefaults,
     AppManifest,
+    CustomActionWay,
     DefaultsDefinition,
     DynamicIODefinition,
     DynamicIoOwnership,
     DynamicIoType,
     Flags,
     IOSchema,
+    ManifCustomAction,
     RuntimeUpdateFlags,
     SchemasDefinition,
 )
@@ -27,6 +29,7 @@ class RuntimeUpdateConfig(ConfigBaseModel):
 
 class ImporterFlags(ConfigBaseModel):
     enable_runtime_update: RuntimeUpdateConfig = RuntimeUpdateConfig()
+    resources_required: Optional[bool] = None
 
 
 class SchemasConfig(ConfigBaseModel):
@@ -53,6 +56,7 @@ class ImporterConfig(AppBaseConfig):
     importer_io: List[ImporterIO] = []
     ui_schemas: SchemasConfig = SchemasConfig()
     defaults: DeploymentDefaults = DeploymentDefaults()
+    custom_actions: CustomActionsIO = CustomActionsIO()
 
     def to_manifest(self, read_schemas: bool = True, workdir: Path = Path(".")) -> AppManifest:
         return convert_importer_to_manifest(self, read_schemas=read_schemas, workdir=workdir)
@@ -71,6 +75,10 @@ def convert_importer_to_manifest(
             for io, schema_path in config.ui_schemas.io_configuration.items()
         ]
 
+    manif_custom_actions = [
+        ManifCustomAction(type=cai.type, way=CustomActionWay.input_ca) for cai in config.custom_actions.inputs
+    ] + [ManifCustomAction(type=cai.type, way=CustomActionWay.output_ca) for cai in config.custom_actions.outputs]
+
     return AppManifest(
         name=config.name,
         title=config.title,
@@ -81,6 +89,7 @@ def convert_importer_to_manifest(
         flags=Flags(
             spec_version=config.spec_version,
             enable_runtime_update=RuntimeUpdateFlags(configuration=config.flags.enable_runtime_update.configuration),
+            resources_required=config.flags.resources_required,
         ),
         dynamic_io=[
             DynamicIODefinition(
@@ -95,4 +104,5 @@ def convert_importer_to_manifest(
         defaults=DefaultsDefinition(
             app=AppDefaults(configuration=config.defaults.configuration), system=config.defaults.system
         ),
+        custom_actions=manif_custom_actions,
     )

{kelvin_python_sdk-0.2.0 → kelvin_python_sdk-0.2.3}/kelvin/config/manifest.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, List, Literal, Optional
 
 from pydantic import Field
 
-from kelvin.config.common import AppBaseConfig, ConfigBaseModel, VersionStr
+from kelvin.config.common import AppBaseConfig, ConfigBaseModel, CustomActionTypeStr, VersionStr
 from kelvin.krn import KRN
 from kelvin.message import ParameterType
 from kelvin.message.msg_type import PrimitiveTypes
@@ -26,6 +26,7 @@ class Flags(ConfigBaseModel):
     spec_version: VersionStr
     enable_runtime_update: RuntimeUpdateFlags = RuntimeUpdateFlags()
     deployment: DeploymentFlags = DeploymentFlags()
+    resources_required: Optional[bool] = None
 
 
 class IOWay(str, Enum):
@@ -74,6 +75,16 @@ class DynamicIODefinition(ConfigBaseModel):
     data_types: List[str] = []
 
 
+class CustomActionWay(str, Enum):
+    input_ca = "input-ca"
+    output_ca = "output-ca"
+
+
+class ManifCustomAction(ConfigBaseModel):
+    type: CustomActionTypeStr
+    way: CustomActionWay
+
+
 class ParamDefinition(ConfigBaseModel):
     name: str
     title: Optional[str] = None
@@ -136,3 +147,4 @@ class AppManifest(AppBaseConfig):
     parameters: List[ParamDefinition] = []
     schemas: SchemasDefinition = SchemasDefinition()
     defaults: DefaultsDefinition = DefaultsDefinition()
+    custom_actions: List[ManifCustomAction] = []

{kelvin_python_sdk-0.2.0 → kelvin_python_sdk-0.2.3}/kelvin/config/smart_app.py

@@ -3,18 +3,27 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, List, Literal, Optional
 
-from kelvin.config.common import AppBaseConfig, AppTypes, ConfigBaseModel, ConfigError, read_schema_file
+from kelvin.config.common import (
+    AppBaseConfig,
+    AppTypes,
+    ConfigBaseModel,
+    ConfigError,
+    CustomActionsIO,
+    read_schema_file,
+)
 from kelvin.message import ParameterType
 from kelvin.message.msg_type import PrimitiveTypes
 
 from .manifest import (
     AppDefaults,
     AppManifest,
+    CustomActionWay,
     DefaultsDefinition,
     Flags,
     IODatastreamMapping,
     IODefinition,
     IOWay,
+    ManifCustomAction,
     ParamDefinition,
     RuntimeUpdateFlags,
     SchemasDefinition,
@@ -75,6 +84,7 @@ class SmartAppConfig(AppBaseConfig):
     parameters: List[SmartAppParams] = []
     ui_schemas: SchemasConfig = SchemasConfig()
     defaults: DeploymentDefaults = DeploymentDefaults()
+    custom_actions: CustomActionsIO = CustomActionsIO()
 
     def to_manifest(self, read_schemas: bool = True, workdir: Path = Path(".")) -> AppManifest:
         return convert_smart_app_to_manifest(self, read_schemas=read_schemas, workdir=workdir)
@@ -147,6 +157,10 @@ def convert_smart_app_to_manifest(
             read_schema_file(workdir / config.ui_schemas.parameters) if config.ui_schemas.parameters else {}
         )
 
+    manif_custom_actions = [
+        ManifCustomAction(type=cai.type, way=CustomActionWay.input_ca) for cai in config.custom_actions.inputs
+    ] + [ManifCustomAction(type=cai.type, way=CustomActionWay.output_ca) for cai in config.custom_actions.outputs]
+
     return AppManifest(
         name=config.name,
         title=config.title,
@@ -162,6 +176,7 @@ def convert_smart_app_to_manifest(
                 resource_properties=config.flags.enable_runtime_update.resource_properties,
                 configuration=config.flags.enable_runtime_update.configuration,
             ),
+            resources_required=True,
         ),
         parameters=[
             ParamDefinition(name=p.name, data_type=p.data_type, default=config.defaults.parameters.get(p.name))
@@ -173,4 +188,5 @@ def convert_smart_app_to_manifest(
             app=AppDefaults(configuration=config.defaults.configuration, io_datastream_mapping=io_map),
             system=config.defaults.system,
         ),
+        custom_actions=manif_custom_actions,
     )