feat!: core managed components functionality

docs/docs/component-list.md

@@ -3,21 +3,8 @@ outline: [2, 2]
 ---
 
 <script setup>
-    import { generateCore } from "../../ui/src/core"
-    const ss = generateCore();
-    const types = ss.getSupportedComponentTypes();
-    const defs = types.map(type => {
-        const def = ss.getComponentDefinition(type);
-        return {
-            type,
-            name: def.name,
-            docs: def.docs,
-            description: def.description,
-            fields: def.fields,
-            events: def.events,
-            category: def.category
-        }
-    });
+    import defs from "streamsync-ui/components.json";
+
     const categories = {
         "Layout": "Components to organise the app's layout. Not meaningful by themselves; their objective is to enhance how other components are presented.",
         "Content": "Components that present content and are meaningful by themselves. For example, charts, images or text.",

docs/package.json

@@ -9,6 +9,7 @@
     "preview": "vitepress preview docs"
   },
   "dependencies": {
+		"streamsync-ui": "*",
     "vitepress": "^1.0.0-rc.44",
     "vue": "^3.4.21"
   }

src/streamsync/app_runner.py

@@ -324,6 +324,14 @@ def _main(self) -> None:
 
         terminate_early = False
 
+        try:
+            streamsync.base_component_tree.ingest(self.bmc_components)
+        except BaseException:
+            streamsync.initial_state.add_log_entry(
+                "error", "UI Components Error", "Couldn't load components. An exception was raised.", tb.format_exc())
+            if self.mode == "run":
+                terminate_early = True
+
         try:
             self._execute_user_code()
         except BaseException:
@@ -337,14 +345,6 @@ def _main(self) -> None:
             if self.mode == "run":
                 terminate_early = True
 
-        try:
-            streamsync.base_component_tree.ingest(self.bmc_components)
-        except BaseException:
-            streamsync.initial_state.add_log_entry(
-                "error", "UI Components Error", "Couldn't load components. An exception was raised.", tb.format_exc())
-            if self.mode == "run":
-                terminate_early = True
-
         if terminate_early:
             self._terminate_early()
             return
@@ -671,7 +671,7 @@ async def init_session(self, payload: InitSessionRequestPayload) -> AppProcessSe
         return await self.dispatch_message(None, InitSessionRequest(
             type="sessionInit",
             payload=payload
-        ))
+        ))    
 
     async def update_components(self, session_id: str, payload: ComponentUpdateRequestPayload) -> AppProcessServerResponse:
         if self.mode != "edit":

src/streamsync/core.py

@@ -6,7 +6,6 @@
 import logging
 import secrets
 import sys
-import threading
 import time
 import traceback
 from typing import Any, Callable, Dict, List, Literal, Optional, Set, Tuple, Union
@@ -17,7 +16,7 @@
 import json
 import math
 from streamsync.ss_types import Readable, InstancePath, StreamsyncEvent, StreamsyncEventResult, StreamsyncFileItem
-from pydantic import BaseModel, Field
+from streamsync.core_ui import ComponentTree, SessionComponentTree
 
 
 class Config:
@@ -474,101 +473,6 @@ def call_frontend_function(self, module_key: str, function_name: str, args: List
         })
 
 
-# TODO Consider switching Component to use Pydantic
-
-class Component(BaseModel):
-    id: str
-    type: str
-    content: Dict[str, str] = Field(default_factory=dict)
-    flag: Optional[str] = None
-    position: int = 0
-    parentId: Optional[str] = None
-    handlers: Optional[Dict[str, str]] = None
-    visible: Optional[Union[bool, str]] = None
-    binding: Optional[Dict] = None
-
-    def to_dict(self) -> Dict:
-        """
-        Wrapper for model_dump to ensure backward compatibility.
-        """
-        return self.model_dump(exclude_none=True)
-
-
-class ComponentTree:
-
-    def __init__(self) -> None:
-        self.counter: int = 0
-        self.components: Dict[str, Component] = {}
-        root_component = Component(
-            id="root", type="root", content={}
-        )
-        self.attach(root_component)
-
-    def get_component(self, component_id: str) -> Optional[Component]:
-        return self.components.get(component_id)
-
-    def get_descendents(self, parent_id: str) -> List[Component]:
-        children = list(filter(lambda c: c.parentId == parent_id,
-                               self.components.values()))
-        desc = children.copy()
-        for child in children:
-            desc += self.get_descendents(child.id)
-
-        return desc
-
-    def attach(self, component: Component) -> None:
-        self.counter += 1
-        self.components[component.id] = component
-
-    def ingest(self, serialised_components: Dict[str, Any]) -> None:
-        removed_ids = self.components.keys() - serialised_components.keys()
-
-        for component_id in removed_ids:
-            if component_id == "root":
-                continue
-            self.components.pop(component_id)
-        for component_id, sc in serialised_components.items():
-            component = Component(**sc)
-            self.components[component_id] = component
-
-    def to_dict(self) -> Dict:
-        active_components = {}
-        for id, component in self.components.items():
-            active_components[id] = component.to_dict()
-        return active_components
-
-
-class SessionComponentTree(ComponentTree):
-
-    def __init__(self, base_component_tree: ComponentTree):
-        super().__init__()
-        self.base_component_tree = base_component_tree
-
-    def get_component(self, component_id: str) -> Optional[Component]:
-        # Check if session component tree contains requested key
-        session_component_present = component_id in self.components
-
-        if session_component_present:
-            # If present, return session component (even if it's None)
-            session_component = self.components.get(component_id)
-            return session_component
-
-        # Otherwise, try to obtain the base tree component
-        return self.base_component_tree.get_component(component_id)
-
-    def to_dict(self) -> Dict:
-        active_components = {
-            # Collecting serialized base tree components
-            component_id: base_component.to_dict()
-            for component_id, base_component
-            in self.base_component_tree.components.items()
-        }
-        for component_id, session_component in self.components.items():
-            # Overriding base tree components with session-specific ones
-            active_components[component_id] = session_component.to_dict()
-        return active_components
-
-
 class EventDeserialiser:
 
     """Applies transformations to the payload of an incoming event, depending on its type.
@@ -1079,6 +983,10 @@ def _call_handler_callable(self, event_type, target_component, instance_path, pa
                     "headers": self.session.headers
                 }
                 arg_values.append(session_info)
+            elif arg == "ui":
+                from streamsync.ui import StreamsyncUIManager
+                ui_manager = StreamsyncUIManager(self.session.session_component_tree)
+                arg_values.append(ui_manager)
 
         result = None
         if is_async_handler:

src/streamsync/core_ui.py

@@ -0,0 +1,148 @@
+from contextvars import ContextVar
+from typing import Any, Dict, List, Optional, Union
+import uuid
+
+from pydantic import BaseModel, Field
+
+current_parent_container: ContextVar[Union["Component", None]] = \
+    ContextVar("current_parent_container")
+# This variable is thread safe and context safe
+
+
+def generate_component_id():
+    return str(uuid.uuid4())
+
+
+class Component(BaseModel):
+    id: str = Field(default_factory=generate_component_id)
+    type: str
+    content: Dict[str, Any] = Field(default_factory=dict)
+    flag: Optional[str] = None
+    position: int = 0
+    parentId: Optional[str] = None
+    handlers: Optional[Dict[str, str]] = None
+    visible: Optional[Union[bool, str]] = None
+    binding: Optional[Dict] = None
+
+    def to_dict(self) -> Dict:
+        """
+        Wrapper for model_dump to ensure backward compatibility.
+        """
+        return self.model_dump(exclude_none=True)
+
+    def __enter__(self) -> "Component":
+        self._token = current_parent_container.set(self)
+        return self
+
+    def __exit__(self, *_):
+        current_parent_container.reset(self._token)
+
+
+class ComponentTree:
+
+    def __init__(self, attach_root=True) -> None:
+        self.counter: int = 0
+        self.components: Dict[str, Component] = {}
+        if attach_root:
+            root_component = Component(
+                id="root", type="root", content={}
+            )
+            self.attach(root_component)
+
+    def get_component(self, component_id: str) -> Optional[Component]:
+        return self.components.get(component_id)
+
+    def get_direct_descendents(self, parent_id: str) -> List[Component]:
+        children = list(filter(lambda c: c.parentId == parent_id,
+                               self.components.values()))
+        return children
+
+    def get_direct_descendents_length(self, parent_id):
+        return len(self.get_direct_descendents(parent_id))
+
+    def get_descendents(self, parent_id: str) -> List[Component]:
+        children = self.get_direct_descendents(parent_id)
+        desc = children.copy()
+        for child in children:
+            desc += self.get_descendents(child.id)
+
+        return desc
+
+    def determine_position(self, _: str, parent_id: str, is_positionless: bool = False):
+        if is_positionless:
+            return -2
+
+        children = self.get_direct_descendents(parent_id)
+        if len(children) > 0:
+            position = max([0, max([child.position for child in children]) + 1])
+            return position
+        else:
+            return 0
+
+    def attach(self, component: Component, override=False) -> None:
+        self.counter += 1
+        if (component.id in self.components) and (override is False):
+            raise RuntimeWarning(f"Component with ID {component.id} already exists")
+        self.components[component.id] = component
+
+    def ingest(self, serialised_components: Dict[str, Any]) -> None:
+        removed_ids = self.components.keys() - serialised_components.keys()
+
+        for component_id in removed_ids:
+            if component_id == "root":
+                continue
+            self.components.pop(component_id)
+        for component_id, sc in serialised_components.items():
+            component = Component(**sc)
+            self.components[component_id] = component
+
+    def to_dict(self) -> Dict:
+        active_components = {}
+        for id, component in self.components.items():
+            active_components[id] = component.to_dict()
+        return active_components
+
+
+class SessionComponentTree(ComponentTree):
+
+    def __init__(self, base_component_tree: ComponentTree):
+        super().__init__(attach_root=False)
+        self.base_component_tree = base_component_tree
+
+    def determine_position(self, component_id: str, parent_id: str, is_positionless: bool = False):
+        session_component_present = component_id in self.components
+        if session_component_present:
+            # If present, use ComponentTree method
+            # for determining position directly from this class
+            return super().determine_position(component_id, parent_id, is_positionless)
+        else:
+            # Otherwise, invoke it on base component tree
+            return self.base_component_tree.determine_position(component_id, parent_id, is_positionless)
+
+    def get_component(self, component_id: str) -> Optional[Component]:
+        # Check if session component tree contains requested key
+        session_component_present = component_id in self.components
+
+        if session_component_present:
+            # If present, return session component (even if it's None)
+            session_component = self.components.get(component_id)
+            return session_component
+
+        # Otherwise, try to obtain the base tree component
+        return self.base_component_tree.get_component(component_id)
+
+    def to_dict(self) -> Dict:
+        active_components = {
+            # Collecting serialized base tree components
+            component_id: base_component.to_dict()
+            for component_id, base_component
+            in self.base_component_tree.components.items()
+        }
+        for component_id, session_component in self.components.items():
+            # Overriding base tree components with session-specific ones
+            active_components[component_id] = session_component.to_dict()
+        return active_components
+
+
+class UIError(Exception):
+    ...

src/streamsync/ss_types.py

@@ -134,7 +134,7 @@ class EventResponsePayload(BaseModel):
     result: Any
     mutations: Dict[str, Any]
     mail: List
-    components: Dict
+    components: Optional[Dict] = None
 
 
 class StateEnquiryResponsePayload(BaseModel):