rainbow-rb-flow-manager 0.1.2.dev2__tar.gz → 0.1.2.dev4__tar.gz

{rainbow_rb_flow_manager-0.1.2.dev2 → rainbow_rb_flow_manager-0.1.2.dev4}/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: rainbow-rb-flow-manager
-Version: 0.1.2.dev2
+Version: 0.1.2.dev4
 Summary: Rainbow Python Flow Manager
 Author-email: Derek <dfd1123@rainbow-robotics.com>
 Requires-Python: <3.14,>=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: rainbow-rb-utils==0.1.2.dev2
-Requires-Dist: rainbow-rb-zenoh==0.1.2.dev2
-Requires-Dist: rainbow-rb-flat-buffers==0.1.2.dev2
-Requires-Dist: rainbow-rb-schemas==0.1.2.dev2
-Requires-Dist: rainbow-rb-sdk==0.1.2.dev2
-Requires-Dist: rainbow-rb-log==0.1.2.dev2
+Requires-Dist: rainbow-rb-utils==0.1.2.dev4
+Requires-Dist: rainbow-rb-zenoh==0.1.2.dev4
+Requires-Dist: rainbow-rb-flat-buffers==0.1.2.dev4
+Requires-Dist: rainbow-rb-schemas==0.1.2.dev4
+Requires-Dist: rainbow-rb-sdk==0.1.2.dev4
+Requires-Dist: rainbow-rb-log==0.1.2.dev4
 
 # rb_flow_manager 사용 설명서
 

{rainbow_rb_flow_manager-0.1.2.dev2 → rainbow_rb_flow_manager-0.1.2.dev4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rainbow-rb-flow-manager"
-version = "0.1.2.dev2"
+version = "0.1.2.dev4"
 requires-python = ">=3.11,<3.14"
 description = "Rainbow Python Flow Manager"
 authors = [
@@ -13,12 +13,12 @@ authors = [
 readme = "README.md"
 
 dependencies = [
-    "rainbow-rb-utils==0.1.2.dev2",
-    "rainbow-rb-zenoh==0.1.2.dev2",
-    "rainbow-rb-flat-buffers==0.1.2.dev2",
-    "rainbow-rb-schemas==0.1.2.dev2",
-    "rainbow-rb-sdk==0.1.2.dev2",
-    "rainbow-rb-log==0.1.2.dev2",
+    "rainbow-rb-utils==0.1.2.dev4",
+    "rainbow-rb-zenoh==0.1.2.dev4",
+    "rainbow-rb-flat-buffers==0.1.2.dev4",
+    "rainbow-rb-schemas==0.1.2.dev4",
+    "rainbow-rb-sdk==0.1.2.dev4",
+    "rainbow-rb-log==0.1.2.dev4",
 ]
 
 [tool.setuptools]

{rainbow_rb_flow_manager-0.1.2.dev2 → rainbow_rb_flow_manager-0.1.2.dev4}/src/rainbow/rb_flow_manager/context.py

@@ -16,9 +16,8 @@ from multiprocessing.synchronize import (
 )
 from typing import Any, Literal, cast
 
-from rainbow.rb_sdk.base import RBBaseSDK
-from rainbow.rb_sdk.rb_sdk_cpp import RBAmrSDK, RBManipulateSDK, RBProgramSDK
-from rainbow.rb_utils.flow_manager import eval_value, make_builtins_allow_most
+from rainbow.rb_sdk import RBAmrSDK, RBBaseSDK, RBManipulateSDK, RBProgramSDK
+from rainbow.rb_utils.flow_manager import collect_rb_globals, eval_value, make_builtins_allow_most
 from rainbow.rb_utils.parser import t_to_dict
 
 from .exception import BreakFolder, StopExecution, SubTaskHaltException
@@ -135,9 +134,17 @@ class ExecutionContext:
         """
         code = compile(contents, "<custom_script>", "exec")
 
-        script_globals = {"__builtins__": make_builtins_allow_most(), **script_locals}
+        script_globals = {
+            "__builtins__": make_builtins_allow_most(),
+            **self.program_aliases,  # P_0, P_1, ... → process_id
+            **script_locals,
+        }
         exec(code, script_globals)  # pylint: disable=exec-used
 
+    @property
+    def program_aliases(self) -> dict[str, str]:
+        return dict((getattr(self, "state_dict", None) or {}).get("program_aliases") or {})
+
     def _resolve_variable_owner_state(self) -> ExecutorState:
         if self.parent_process_id is not None and self.shared_state_dicts is not None:
             parent_state = self.shared_state_dicts.get(self.parent_process_id)
@@ -157,7 +164,7 @@ class ExecutionContext:
             normalized[key] = {"value": payload.get("value"), "type": var_type}
         return normalized
 
-    def eval_value(self, value: Any, use_get_var: bool = False):
+    def eval_value(self, value: Any):
         """
         표현식 평가의 단일 진입점.
         읽기는 매번 owner state에서 최신값을, 쓰기(aa = 3, aa += 1)는 owner state까지 반영한다.
@@ -171,8 +178,9 @@ class ExecutionContext:
         result = eval_value(
             value,
             variables=self.variables,
-            get_global_variable=self.get_global_variable,
-            get_var=self.get_var if use_get_var else None,
+            get_global_variable=self.global_variable_getter(value),
+            get_var=self.get_var,
+            update_var=self.update_var,
             on_write=lambda name, scope: (
                 written_global if scope == "global" else written_local
             ).add(name),
@@ -251,32 +259,80 @@ class ExecutionContext:
         if category is None or robot_model is None:
             return None
 
-        try:
-            if category == "manipulate":
-                fn = self.get_sdk_function("rb_manipulate_sdk.get_data.get_variable")
+        if category not in ("manipulate", "amr"):
+            return None
 
-                res = fn(robot_model=robot_model, name=var_name) if fn is not None else None
+        res = self._fetch_core_variable(category, robot_model, var_name)
+        if res is None:
+            raise RuntimeError(f"Failed to get global variable: {var_name}")
 
-                if res is None:
-                    raise RuntimeError(f"Failed to get global variable: {var_name}")
+        self.update_global_variables({var_name: res})
 
-                self.update_global_variables({var_name: res})
+        return res
 
-                return res
-            elif category == "amr":
-                # SLAMNAV2랑 얘기해서 추가해야함 (RB_로 시작하는 global variable)
-                fn = self.get_sdk_function("rb_amr_sdk.status.get_variable")
+    def global_variable_getter(self, value: Any) -> Callable[[str], Any]:
+        """RB_ 이름이 여러 개면 한 번에 선조회한 값을 쓰는 getter. 못 읽은 이름은 개별 조회."""
+        prefetched = self._prefetch_global_variables(value)
+        if not prefetched:
+            return self.get_global_variable
 
-                res = fn(robot_model, var_name) if fn is not None else None
+        return lambda name: (
+            prefetched[name] if name in prefetched else self.get_global_variable(name)
+        )
 
-                if res is None:
-                    raise RuntimeError(f"Failed to get global variable: {var_name}")
+    def _prefetch_global_variables(self, value: Any) -> dict[str, Any]:
+        """RB_ 이름 2개 이상이면 get_core_data_multi 로 한 번에 읽는다. 실패하면 {}."""
+        names = collect_rb_globals(value)
+        if len(names) < 2:
+            return {}
 
-                self.update_global_variables({var_name: res})
+        robot_model = self.state_dict.get("robot_model", None)
+        category = self.state_dict.get("category", None)
+        if category is None or robot_model is None:
+            return {}
 
-                return res
-        except Exception as e:
-            raise e
+        fetched = self._fetch_core_variables_multi(category, robot_model, names)
+        if not fetched:
+            return {}
+
+        self.update_global_variables(fetched)
+        return fetched
+
+    def _fetch_core_variables_multi(self, category: Any, robot_model: Any, names: list[str]) -> dict[str, Any]:
+        """get_core_data_multi 1회. SDK 에 없거나(구버전/amr) core 가 안 띄웠으면 {} → 개별 조회.
+        queryable 이 없으면 ZenohNoReply 가 즉시 나므로 미지원을 기억할 필요 없다."""
+        if category == "manipulate":
+            fn = self.get_sdk_function("rb_manipulate_sdk.get_data.get_variables")
+        elif category == "amr":
+            return {}  # amr 은 아직 multi 없음
+        else:
+            return {}
+        if fn is None:
+            return {}
+
+        try:
+            res = fn(robot_model=robot_model, names=names)
+        except Exception:
+            return {}
+
+        if not isinstance(res, dict):
+            return {}
+
+        # valid=0(None) 은 캐시하지 않고 개별 조회로 넘긴다
+        return {name: value for name, value in res.items() if value is not None}
+
+    def _fetch_core_variable(self, category: Any, robot_model: Any, var_name: str) -> Any:
+        """대상 로봇 core(get_core_data)에서 RB_ 변수 라이브 조회. 다른 category/실패 시 None."""
+        if robot_model is None:
+            return None
+        if category == "manipulate":
+            fn = self.get_sdk_function("rb_manipulate_sdk.get_data.get_variable")
+            return fn(robot_model=robot_model, name=var_name) if fn is not None else None
+        if category == "amr":
+            # SLAMNAV2랑 얘기해서 추가해야함 (RB_로 시작하는 global variable)
+            fn = self.get_sdk_function("rb_amr_sdk.status.get_variable")
+            return fn(robot_model, var_name) if fn is not None else None
+        return None
 
     def merge_variable_meta(self, name: str, meta: dict[str, Any]) -> None:
         """변수 entry 의 meta 에 merge. value 는 건드리지 않는다 (dict 값은 얕게 merge)."""
@@ -314,8 +370,17 @@ class ExecutionContext:
                 continue
             merge_variable_entries(sd, variables, meta_by_name=meta_by_name)
 
-    def get_var(self, pid_or_robot_model: str, var_name: str, default: Any = _MISSING) -> Any:
+    def get_var(
+        self, pid_or_robot_model: str, var_name: Any = _MISSING, default: Any = _MISSING
+    ) -> Any:
+        """get_var(name[, default=]) = 자기 변수, get_var(pid|robot_model|plugin_id, name[, default])."""
+        if var_name is _MISSING:
+            return self._read_state_var(
+                self._resolve_variable_owner_state(), pid_or_robot_model, default, "self"
+            )
+
         all_dicts = self.shared_state_dicts or {}
+        pid_or_robot_model = self.program_aliases.get(pid_or_robot_model, pid_or_robot_model)
 
         # pid 직접 매치 우선, 없으면 robot_model로 탐색
         target_state = all_dicts.get(pid_or_robot_model)
@@ -338,17 +403,77 @@ class ExecutionContext:
                 return default
             raise RuntimeError(f"get_var: process '{pid_or_robot_model}' not found")
 
-        raw_vars: dict[str, Any] = dict(target_state.get("variables", {}))
-        entry = raw_vars.get(var_name)
+        return self._read_state_var(target_state, var_name, default, pid_or_robot_model)
+
+    def _read_state_var(self, state: Any, var_name: Any, default: Any, label: str) -> Any:
+        # RB_ 는 core 라이브 조회 우선, 실패 시 state 캐시 폴백 (safe_eval_expr 와 동일)
+        live_err: Exception | None = None
+        if isinstance(var_name, str) and var_name.startswith("RB_"):
+            try:
+                live = self._fetch_core_variable(
+                    state.get("category"), state.get("robot_model"), var_name
+                )
+            except Exception as e:  # noqa: BLE001
+                live, live_err = None, e
+            if live is not None:
+                return live
+
+        entry = dict(state.get("variables", {})).get(var_name)
         if entry is None:
             if default is not _MISSING:
                 return default
             raise RuntimeError(
-                f"get_var: variable '{var_name}' not found in '{pid_or_robot_model}'"
-            )
+                f"get_var: variable '{var_name}' not found in '{label}'"
+            ) from live_err
 
         return entry.get("value") if isinstance(entry, dict) else entry
 
+    def update_var(self, target: Any, variables: dict[str, Any] | None = None) -> None:
+        """update({...}) = 자기, update(pid|robot_model|plugin_id, {...}) = 다른 프로그램.
+
+        plugin_id 는 플러그인 set_variable 과 동일(RBP_ 만, 전체 main + writer 기록).
+        """
+        if variables is None:
+            self.update_local_variables(target)
+            return
+
+        variables = dict(variables)
+        all_dicts = self.shared_state_dicts or {}
+        target = self.program_aliases.get(target, target)
+        own_pid = (
+            self.parent_process_id if self.parent_process_id in all_dicts else self.process_id
+        )
+        active_mains = [
+            pid
+            for pid, sd in all_dicts.items()
+            if sd.get("parent_process_id") is None and sd.get("state") in VARIABLE_TARGET_STATES
+        ]
+        meta_by_name: dict[str, dict[str, Any]] | None = None
+
+        if target in all_dicts:
+            parent = all_dicts[target].get("parent_process_id")
+            pids = [parent if parent in all_dicts else target]
+        elif any(sd.get("robot_model") == target for sd in all_dicts.values()):
+            pids = [pid for pid in active_mains if all_dicts[pid].get("robot_model") == target]
+        else:
+            bad = [name for name in variables if not str(name).startswith("RBP_")]
+            if bad:
+                raise ValueError(
+                    f"update: '{target}' is not a running robot model; "
+                    f"plugin variable must start with 'RBP_': {bad}"
+                )
+            pids = active_mains
+            meta_by_name = {name: {"writers": {target: v}} for name, v in variables.items()}
+
+        for pid in pids:
+            if pid == own_pid:
+                # 자기 트리는 캐시/dirty 경로로 즉시 반영
+                self.update_local_variables(variables)
+                for name, meta in (meta_by_name or {}).items():
+                    self.merge_variable_meta(name, meta)
+            else:
+                merge_variable_entries(all_dicts[pid], variables, meta_by_name=meta_by_name)
+
     def _ensure_sdk_roots(self):
         if self._sdk_roots is not None:
             return
@@ -837,6 +962,10 @@ class ExecutionContext:
         with contextlib.suppress(Exception):
             RBBaseSDK.close_all_for_pid()
 
+        # AMR 은 아직 Python SDK 라 C++ 레지스트리가 아니라 Python RBBaseSDK._instances 에 있다.
+        with contextlib.suppress(Exception):
+            RBAmrSDK.close_all_for_pid()
+
     def close(self):
         """안전하게 close"""
         self._safe_close_sdk()

{rainbow_rb_flow_manager-0.1.2.dev2 → rainbow_rb_flow_manager-0.1.2.dev4}/src/rainbow/rb_flow_manager/executor.py

@@ -114,6 +114,24 @@ def _build_executor_state(
     }
 
 
+def _declared_variables(step: Step | None) -> dict[str, dict[str, Any]]:
+    """트리의 set_variables 스텝 init_value 수집."""
+    out: dict[str, dict[str, Any]] = {}
+
+    def walk(s: Any):
+        if getattr(s, "disabled", False):
+            return
+        if getattr(s, "func_name", None) == "rb_program_sdk.set_variables":
+            for v in (getattr(s, "args", None) or {}).get("variables") or []:
+                if isinstance(v, dict) and isinstance(v.get("name"), str):
+                    out.setdefault(v["name"], {"value": v.get("init_value"), "type": "local"})
+        for c in getattr(s, "children", None) or []:
+            walk(c)
+
+    walk(step)
+    return out
+
+
 def _apply_executor_state(state_dict: MutableMapping[str, Any], state: ExecutorState):
     for key, value in state.items():
         state_dict[key] = value
@@ -245,12 +263,19 @@ def _execute_tree_in_process(
         state_dict["state"] = RB_Flow_Manager_ProgramState.ERROR
         state_dict["error"] = msg
 
-    def emit_error_or_stop(step_id: str, msg: str):
-        if ctx is None:
-            return
-        if "Execution stopped by user" in msg:
+    def mark_stopped(step_id: str):
+        state_dict["state"] = RB_Flow_Manager_ProgramState.STOPPED
+        state_dict["stop_requested"] = True
+        # 이미 알려진 정지(부모 stop()/ctx.stop())는 되쏘지 않는다
+        if ctx is not None and not ctx.stop_event.is_set():
             ctx.emit_stop(step_id)
-        else:
+
+    def set_error_or_stop(step_id: str, msg: str):
+        if "Execution stopped by user" in msg:
+            mark_stopped(step_id)
+            return
+        set_error(msg)
+        if ctx is not None:
             ctx.emit_error(step_id, RuntimeError(msg))
 
     def init_state():
@@ -519,15 +544,11 @@ def _execute_tree_in_process(
 
         except StopExecution:
             # stop 요청 상태로 마킹 (post_step는 정책상 실행 가능)
-            state_dict["state"] = RB_Flow_Manager_ProgramState.STOPPED
-            state_dict["stop_requested"] = True
-            if ctx is not None:
-                ctx.emit_stop(step.step_id)
+            mark_stopped(step.step_id)
 
         except (RuntimeError, ValueError) as e:
             # post_step 유무와 무관하게 항상 ERROR 로 표시한다. STOPPED 는 이미 그렇다.
-            set_error(str(e))
-            emit_error_or_stop(step.step_id, str(e))
+            set_error_or_stop(step.step_id, str(e))
 
         except JumpToStepException:
             # 메인 루프 바깥으로 점프 예외가 올라오는 경우는 무시
@@ -548,14 +569,10 @@ def _execute_tree_in_process(
             pass
 
         except StopExecution:
-            state_dict["state"] = RB_Flow_Manager_ProgramState.STOPPED
-            state_dict["stop_requested"] = True
-            if ctx is not None:
-                ctx.emit_stop(step.step_id)
+            mark_stopped(step.step_id)
 
         except (RuntimeError, ValueError) as e:
-            set_error(str(e))
-            emit_error_or_stop(step.step_id, str(e))
+            set_error_or_stop(step.step_id, str(e))
 
         except JumpToStepException as e:
             raise RuntimeError("JumpToStep: Post program tree is not allowed.") from e
@@ -947,6 +964,32 @@ class ScriptExecutor:
             if self.controller is not None:
                 self.controller.on_all_resume()
 
+    def _apply_stop_transition(
+        self,
+        process_id: str,
+        *,
+        step_id: str | None,
+        sub_task: tuple[str | None, str | None],
+    ):
+        self.state_dicts[process_id]["state"] = RB_Flow_Manager_ProgramState.STOPPED
+        self.state_dicts[process_id]["ignore_pause"] = False
+
+        sub_task_id, sub_task_type = sub_task
+        if step_id is not None:
+            if self._on_stop is not None:
+                self._on_stop(process_id, step_id, sub_task_id, sub_task_type)
+            if self.controller is not None:
+                self.controller.on_stop(process_id, step_id, sub_task_id, sub_task_type)
+
+        if all(
+            self.state_dicts[pid].get("state") == RB_Flow_Manager_ProgramState.STOPPED
+            for pid in self.processes
+        ):
+            if self._on_all_stop is not None:
+                self._on_all_stop()
+            if self.controller is not None:
+                self.controller.on_all_stop()
+
     def _ensure_pre_done_event(self, process_id: str, pre_step: Step | None) -> EventType:
         """
         pre_step 완료 신호를 만든다(이미 있으면 재사용).
@@ -1006,11 +1049,6 @@ class ScriptExecutor:
 
                 self._sync_state[flag] = st
 
-                print(
-                    f"[SyncRegistry] Registered {process_id} to flag '{flag}', "
-                    f"parties_next: {st['parties_next']}"
-                )
-
         return flags
 
     def _unregister_process_sync_flags(self, process_id: str):
@@ -1662,8 +1700,15 @@ class ScriptExecutor:
         self.state_dicts[process_id]["state"] = RB_Flow_Manager_ProgramState.RUNNING
         self.state_dicts[process_id]["current_step_id"] = None
         self.state_dicts[process_id]["ignore_pause"] = False
-        # process_id 재사용 시 이전 실행의 변수 캐시가 남지 않도록 초기화
-        self.state_dicts[process_id]["variables"] = {}
+        # 이전 실행 캐시 제거. main 은 Variables 스텝 init_value 선등록 (Begin 전에도 타 프로세스가 읽게)
+        self.state_dicts[process_id]["variables"] = (
+            {} if parent_process_id is not None else _declared_variables(step)
+        )
+        # P_0, P_1, ... → process_id (main task 순서). 나중에 spawn 되는 자식은 부모 것 상속
+        aliases = args.get("program_aliases")
+        if not aliases and parent_process_id is not None:
+            aliases = self._state_or_empty(parent_process_id).get("program_aliases")
+        self.state_dicts[process_id]["program_aliases"] = dict(aliases or {"P_0": process_id})
 
 
         if invoke_callbacks:
@@ -1763,6 +1808,7 @@ class ScriptExecutor:
         batch_group_id = f"batch-{int(time.time() * 1000)}-{self._run_generation + 1}"
         parent_pids = [arg["process_id"] for arg in batch if arg.get("parent_process_id") is None]
         self._batch_group_parents[batch_group_id] = set(parent_pids)
+        program_aliases = {f"P_{i}": pid for i, pid in enumerate(parent_pids)}
         self._batch_parent_wait_round[batch_group_id] = {}
         self._batch_group_released_round[batch_group_id] = 0
         self._batch_group_child_templates[batch_group_id] = {}
@@ -1789,6 +1835,7 @@ class ScriptExecutor:
             pid = arg["process_id"]
             arg["batch_group_id"] = batch_group_id
             arg["batch_round_sync_parent"] = True
+            arg["program_aliases"] = program_aliases
             if arg.get("parent_process_id") is not None:
                 arg["batch_round_sync_parent"] = False
                 # 배치 자식은 라운드마다 재생성되므로 repeat_count는 1회로 고정한다.
@@ -2027,8 +2074,8 @@ class ScriptExecutor:
             )
 
         elif evt_type == "stop":
-            self.state_dicts[pid]["state"] = RB_Flow_Manager_ProgramState.STOPPED
-            self.state_dicts[pid]["ignore_pause"] = False
+            # 워커가 낸 정지(HALT 스텝 등). 부모 stop() 발 정지는 워커가 되쏘지 않는다
+            self._apply_stop_transition(pid, step_id=step_id, sub_task=(sub_task_id, sub_task_type))
 
         elif evt_type == "round_wait":
             group_id = evt.get("group_id")
@@ -2693,28 +2740,14 @@ class ScriptExecutor:
 
         self.pause_events[process_id].clear()
 
-        step_id = self.state_dicts[process_id].get("current_step_id")
-        self.state_dicts[process_id]["state"] = RB_Flow_Manager_ProgramState.STOPPED
-        self.state_dicts[process_id]["ignore_pause"] = False
-
         self.stop_events[process_id].set()
 
-        if step_id is not None:
-            sub_task_id, sub_task_type = self._current_sub_task_info(process_id)
-            if self._on_stop is not None:
-                self._on_stop(process_id, step_id, sub_task_id, sub_task_type)
-            if self.controller is not None:
-                self.controller.on_stop(process_id, step_id, sub_task_id, sub_task_type)
-
-
-        if all(
-            self.state_dicts[pid].get("state") == RB_Flow_Manager_ProgramState.STOPPED
-            for pid in self.processes
-        ):
-            if self._on_all_stop is not None:
-                self._on_all_stop()
-            if self.controller is not None:
-                self.controller.on_all_stop()
+        step_id = self.state_dicts[process_id].get("current_step_id")
+        self._apply_stop_transition(
+            process_id,
+            step_id=step_id,
+            sub_task=self._current_sub_task_info(process_id),
+        )
 
         print("Process stopped", flush=True)
 

{rainbow_rb_flow_manager-0.1.2.dev2 → rainbow_rb_flow_manager-0.1.2.dev4}/src/rainbow/rb_flow_manager/step.py

@@ -420,7 +420,7 @@ class Step:
                     if self.done_script is not None:
                         print(f"[{ctx.process_id}] executing done_script for step '{self.name}'", flush=True)
                         if isinstance(self.done_script, str):
-                            ctx.eval_value(self.done_script, use_get_var=True)
+                            ctx.eval_value(self.done_script)
                         else:
                             self.done_script()
 
@@ -454,6 +454,9 @@ class Step:
                 eval_args = {}
 
                 try:
+                    # args/variable 의 RB_ 전역 변수를 한 번에 선조회 (core 쿼리 1번)
+                    get_global_variable = ctx.global_variable_getter((args, self.variable))
+
                     for k, v in args.items():
                         if self.not_ast_eval or k.startswith("_"):
                             eval_args[k] = v
@@ -461,7 +464,7 @@ class Step:
                             eval_args[k] = eval_value(
                                 v,
                                 variables=ctx.variables,
-                                get_global_variable=ctx.get_global_variable,
+                                get_global_variable=get_global_variable,
                                 get_var=ctx.get_var,
                             )
 
@@ -483,7 +486,7 @@ class Step:
                                         v = eval_value(
                                             v,
                                             variables=ctx.variables,
-                                            get_global_variable=ctx.get_global_variable,
+                                            get_global_variable=get_global_variable,
                                             get_var=ctx.get_var,
                                         )
 
@@ -807,7 +810,7 @@ class RepeatStep(Step):
         elif self.while_cond is not None:
             if isinstance(self.while_cond, str):
                 while landing_target_step_id is not None or ctx.eval_value(
-                    self.while_cond, use_get_var=True
+                    self.while_cond
                 ):
                     try:
                         self._pre_execute(ctx, is_skip=landing_is_skip)
@@ -860,7 +863,7 @@ class RepeatStep(Step):
                     landing_is_skip = False
                     continue
                 if isinstance(self.do_while, str):
-                    if not ctx.eval_value(self.do_while, use_get_var=True):
+                    if not ctx.eval_value(self.do_while):
                         break
                 else:
                     if not self.do_while(ctx):
@@ -1030,7 +1033,7 @@ class ConditionStep(Step):
                 parent_switch_value = ctx.lookup("switch_value")
                 condition_expr = condition_expr.replace("$parent.switch_value", parent_switch_value)
 
-            if ctx.eval_value(condition_expr, use_get_var=True):
+            if ctx.eval_value(condition_expr):
                 post_execute_and_execute_children()
                 return
 
@@ -1692,11 +1695,6 @@ class SyncStep(Step):
             state["arrived"] = arrived
             ctx.sync_state[flag] = state
 
-            print(
-                f"[Sync {flag}] {pid} arrived ({arrived}/{parties_cur}) phase={current_phase}",
-                flush=True,
-            )
-
             # 마지막 도착자
             if arrived >= parties_cur:
                 # 마지막 도착자
@@ -1734,9 +1732,6 @@ class SyncStep(Step):
 
                     # phase가 넘어갔으면 해제
                     if updated_phase > current_phase:
-                        print(
-                            f"[Sync {flag}] {pid} released from phase {current_phase}", flush=True
-                        )
                         break
 
                     # 중간에 parties가 줄어서(프로세스 제거) 프로세스가 사실상 마지막이 된 경우 처리
@@ -1757,17 +1752,9 @@ class SyncStep(Step):
                         updated["parties_next"] = next_parties
                         ctx.sync_state[flag] = updated
 
-                        print(
-                            f"[Sync {flag}] {pid} becoming last due to parties reduction, "
-                            f"phase {updated_phase} -> {updated_phase + 1}, "
-                            f"parties: {updated_parties_cur} -> {next_parties}",
-                            flush=True,
-                        )
                         ctx.sync_cond.notify_all()
                         break
 
-            print(f"[Sync {flag}] {pid} exiting sync", flush=True)
-
         finally:
             if acquired:
                 ctx.sync_cond.release()

{rainbow_rb_flow_manager-0.1.2.dev2 → rainbow_rb_flow_manager-0.1.2.dev4}/src/rainbow_rb_flow_manager.egg-info/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: rainbow-rb-flow-manager
-Version: 0.1.2.dev2
+Version: 0.1.2.dev4
 Summary: Rainbow Python Flow Manager
 Author-email: Derek <dfd1123@rainbow-robotics.com>
 Requires-Python: <3.14,>=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: rainbow-rb-utils==0.1.2.dev2
-Requires-Dist: rainbow-rb-zenoh==0.1.2.dev2
-Requires-Dist: rainbow-rb-flat-buffers==0.1.2.dev2
-Requires-Dist: rainbow-rb-schemas==0.1.2.dev2
-Requires-Dist: rainbow-rb-sdk==0.1.2.dev2
-Requires-Dist: rainbow-rb-log==0.1.2.dev2
+Requires-Dist: rainbow-rb-utils==0.1.2.dev4
+Requires-Dist: rainbow-rb-zenoh==0.1.2.dev4
+Requires-Dist: rainbow-rb-flat-buffers==0.1.2.dev4
+Requires-Dist: rainbow-rb-schemas==0.1.2.dev4
+Requires-Dist: rainbow-rb-sdk==0.1.2.dev4
+Requires-Dist: rainbow-rb-log==0.1.2.dev4
 
 # rb_flow_manager 사용 설명서
 

rainbow_rb_flow_manager-0.1.2.dev4/src/rainbow_rb_flow_manager.egg-info/requires.txt

@@ -0,0 +1,6 @@
+rainbow-rb-utils==0.1.2.dev4
+rainbow-rb-zenoh==0.1.2.dev4
+rainbow-rb-flat-buffers==0.1.2.dev4
+rainbow-rb-schemas==0.1.2.dev4
+rainbow-rb-sdk==0.1.2.dev4
+rainbow-rb-log==0.1.2.dev4

rainbow_rb_flow_manager-0.1.2.dev2/src/rainbow_rb_flow_manager.egg-info/requires.txt

@@ -1,6 +0,0 @@
-rainbow-rb-utils==0.1.2.dev2
-rainbow-rb-zenoh==0.1.2.dev2
-rainbow-rb-flat-buffers==0.1.2.dev2
-rainbow-rb-schemas==0.1.2.dev2
-rainbow-rb-sdk==0.1.2.dev2
-rainbow-rb-log==0.1.2.dev2