rainbow-rb-utils 0.0.9.dev45__tar.gz → 0.0.73.dev1__tar.gz

{rainbow_rb_utils-0.0.9.dev45 → rainbow_rb_utils-0.0.73.dev1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: rainbow-rb-utils
-Version: 0.0.9.dev45
+Version: 0.0.73.dev1
 Summary: Rainbow Python Utilities
 Author-email: Derek <dfd1123@rainbow-robotics.com>
-Requires-Python: >=3.11
+Requires-Python: <3.14,>=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: psutil<8.0.0,>=7.0.0
-Requires-Dist: rainbow-rb-log==0.0.9.dev45
+Requires-Dist: rainbow-rb-log==0.0.73.dev1
 
 # rb_utils
 

{rainbow_rb_utils-0.0.9.dev45 → rainbow_rb_utils-0.0.73.dev1}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rainbow-rb-utils"
-version = "0.0.9.dev45"
-requires-python = ">=3.11"
+version = "0.0.73.dev1"
+requires-python = ">=3.11,<3.14"
 description = "Rainbow Python Utilities"
 authors = [
     { name = "Derek", email = "dfd1123@rainbow-robotics.com" },
@@ -14,7 +14,7 @@ readme = "README.md"
 
 dependencies = [
     "psutil>=7.0.0,<8.0.0",
-    "rainbow-rb-log==0.0.9.dev45",
+    "rainbow-rb-log==0.0.73.dev1",
 ]
 
 [tool.setuptools]
@@ -26,5 +26,5 @@ where = ["src"]
 include = ["rainbow.rb_utils*"]
 
 [tool.setuptools.package-data]
-"*" = ["py.typed", "*.pyi", "_core*.so", "_core*.pyd"]
+"*" = ["py.typed", "*.pyi", "*.so", "*.pyd"]
 "rainbow.rb_utils" = ["examples/**", "examples/**/*", ".claude/**", ".claude/**/*"]

rainbow_rb_utils-0.0.73.dev1/src/rainbow/rb_utils/flatbuffer.py

@@ -0,0 +1,145 @@
+"""서비스 dict를 생성된 FlatBuffer ``*T`` 객체로 변환하는 유틸리티."""
+
+from __future__ import annotations
+
+import ast
+import importlib
+import importlib.util
+from datetime import datetime
+from enum import Enum
+from functools import lru_cache
+from typing import Any
+
+from rainbow.rb_zenoh.fb_codec import FbTypeError, resolve_fb_type
+
+from rainbow.rb_utils.parser import camel_to_snake
+
+
+@lru_cache(maxsize=256)
+def _field_annotations(t_cls: type) -> dict[str, str]:
+    """flatc가 생성한 sibling ``.pyi``에서 T 객체의 필드 타입을 읽는다."""
+    spec = importlib.util.find_spec(t_cls.__module__)
+    if spec is None or not spec.origin or not spec.origin.endswith(".py"):
+        return {}
+
+    try:
+        with open(spec.origin[:-3] + ".pyi", encoding="utf-8") as file:
+            tree = ast.parse(file.read())
+    except (OSError, SyntaxError):
+        return {}
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef) and node.name == t_cls.__name__:
+            return {
+                statement.target.id: ast.unparse(statement.annotation)
+                for statement in node.body
+                if isinstance(statement, ast.AnnAssign)
+                and isinstance(statement.target, ast.Name)
+            }
+    return {}
+
+
+def _strip_optional(annotation: str) -> str:
+    annotation = annotation.strip()
+    for prefix in ("typing.Optional[", "Optional["):
+        if annotation.startswith(prefix) and annotation.endswith("]"):
+            return annotation[len(prefix):-1].strip()
+    union_parts = [part.strip() for part in annotation.split("|")]
+    if len(union_parts) == 2 and "None" in union_parts:
+        return next(part for part in union_parts if part != "None")
+    return annotation
+
+
+def _list_element_type(annotation: str) -> str | None:
+    annotation = _strip_optional(annotation)
+    for prefix in ("typing.List[", "List[", "list["):
+        if annotation.startswith(prefix) and annotation.endswith("]"):
+            return annotation[len(prefix):-1].strip().strip("'\"")
+    return None
+
+
+def _coerce_literal(annotation: str, value: Any, owner_module: str) -> Any:
+    if not annotation.startswith(("typing.Literal[", "Literal[")):
+        return value
+
+    if isinstance(value, Enum):
+        value = value.value
+    if not isinstance(value, str):
+        return value
+
+    for member in annotation[annotation.index("[") + 1:-1].split(","):
+        enum_name, separator, member_name = member.strip().rpartition(".")
+        if not separator or member_name != value:
+            continue
+        enum_module = importlib.import_module(
+            f"{owner_module.rpartition('.')[0]}.{enum_name}"
+        )
+        enum_cls = getattr(enum_module, enum_name)
+        return getattr(enum_cls, member_name)
+    return value
+
+
+def _coerce_scalar(annotation: str, value: Any, owner_module: str) -> Any:
+    annotation = _strip_optional(annotation)
+    value = _coerce_literal(annotation, value, owner_module)
+
+    if annotation == "int":
+        if isinstance(value, datetime):
+            return int(value.timestamp() * 1000)
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return int(datetime.fromisoformat(value).timestamp() * 1000)
+    if annotation == "float":
+        return float(value)
+    if annotation == "bool":
+        if isinstance(value, str):
+            return value.lower() in {"1", "true", "yes"}
+        return bool(value)
+    if annotation == "str":
+        return str(value)
+    return value
+
+
+def _build_value(annotation: str | None, value: Any, owner_module: str) -> Any:
+    if value is None or annotation is None:
+        return value
+
+    element_type = _list_element_type(annotation)
+    if element_type is not None:
+        values = value if isinstance(value, list | tuple) else [value]
+        return [_build_value(element_type, item, owner_module) for item in values]
+
+    nested_type = _strip_optional(annotation).strip("'\"")
+    if isinstance(value, dict):
+        try:
+            nested_cls = resolve_fb_type(nested_type)
+        except FbTypeError:
+            return value
+        return dict_to_flatbuffer(nested_cls, value)
+
+    return _coerce_scalar(nested_type, value, owner_module)
+
+
+def dict_to_flatbuffer(t_cls: type, data: dict[str, Any]) -> Any:
+    """dict를 ``t_cls``와 중첩된 FlatBuffer T 객체로 재귀 변환한다."""
+    if not isinstance(data, dict):
+        raise TypeError(f"{t_cls.__name__}: dict required, got {type(data).__name__}")
+
+    obj = t_cls()
+    annotations = _field_annotations(t_cls)
+    fields = {key: value for key, value in vars(obj).items() if not key.startswith("_")}
+    normalized_data = {camel_to_snake(key): value for key, value in data.items()}
+
+    for field, default in fields.items():
+        normalized_field = camel_to_snake(field)
+        if normalized_field not in normalized_data:
+            continue
+
+        value = normalized_data[normalized_field]
+        annotation = annotations.get(field)
+        if value is None and default is not None and annotation is not None:
+            continue
+        setattr(obj, field, _build_value(annotation, value, t_cls.__module__))
+
+    return obj

{rainbow_rb_utils-0.0.9.dev45 → rainbow_rb_utils-0.0.73.dev1}/src/rainbow/rb_utils/flow_manager.py

@@ -74,7 +74,9 @@ def safe_eval_expr(
     variables: dict[str, dict[str, Any]] | None = None,
     get_global_variable: Callable[[str], Any] | None = None,
     get_var: Callable[..., Any] | None = None,
+    on_write: Callable[[str, str], None] | None = None,
 ) -> Any:
+    """on_write: 대입/증감 시 (변수명, "local"|"global") 통보. 쓰기 없으면 호출 안 됨."""
     if not isinstance(expr, str):
         return expr
 
@@ -88,7 +90,9 @@ def safe_eval_expr(
     if not s:
         return ""
 
-    is_explicit_expression = bool(EXPLICIT_EXPR_PATTERN.search(s) or RB_GLOBAL_PATTERN.search(s) or GET_VAR_PATTERN.search(s))
+    is_explicit_expression = bool(
+        EXPLICIT_EXPR_PATTERN.search(s) or RB_GLOBAL_PATTERN.search(s) or GET_VAR_PATTERN.search(s)
+    )
     normalized = EXPLICIT_EXPR_PATTERN.sub(lambda match: match.group()[1:], s)
 
     # --- 내부 평가기 ------------------------------------------------------------
@@ -115,15 +119,30 @@ def safe_eval_expr(
                 return ALLOWED_CONSTS[name]
             if name == "math":  # math.* 전용
                 return "math"
-            if name in vars_.get("local", {}):
-                return vars_["local"].get(name)
 
+            # RB_ 는 로봇 시스템변수 예약 네임스페이스다. 항상 라이브 조회가 먼저다.
+            # 캐시를 먼저 보면 한 번 담긴 값(state_monitoring 의 [string] 이거나 이전 조회
+            # 결과)에 갇혀 로봇이 갱신해도 반영되지 않는다.
+            # 라이브 조회가 실패한 경우(로봇 미응답 등)에만 마지막으로 알려진 캐시로 폴백한다.
             if name.startswith("RB_"):
                 global_val = get_global_variable(name) if get_global_variable is not None else None
                 if global_val is not None:
                     return global_val
+
+                if name in vars_.get("local", {}):
+                    return vars_["local"].get(name)
+
+                if name in vars_.get("global", {}):
+                    return vars_["global"].get(name)
+
                 raise ValueError(f"global variable {name} not found")
 
+            if name in vars_.get("local", {}):
+                return vars_["local"].get(name)
+
+            if name in vars_.get("global", {}):
+                return vars_["global"].get(name)
+
             return name  # 모르는 식별자는 문자열로 취급(원하면 여기서 NameError)
 
         if isinstance(node, ast.Attribute):
@@ -187,7 +206,9 @@ def safe_eval_expr(
                 if get_var is None:
                     raise ValueError("get_var is not available in this context")
                 if len(node.args) not in (2, 3):
-                    raise ValueError("get_var requires 2 or 3 arguments: get_var(pid_or_model, var_name[, default])")
+                    raise ValueError(
+                        "get_var requires 2 or 3 arguments: get_var(pid_or_model, var_name[, default])"
+                    )
                 pid_or_model = _eval(node.args[0])
                 var_name = _eval(node.args[1])
                 if len(node.args) == 3:
@@ -225,6 +246,22 @@ def safe_eval_expr(
             return slice(lo, up, st)
         return _eval(sl)
 
+    def _notify_write(target: ast.AST) -> None:
+        """대입 대상의 root 변수명 통보. a[0][1] = 3 → "a" """
+        if on_write is None:
+            return
+
+        node: ast.AST = target
+        while isinstance(node, ast.Subscript | ast.Attribute):
+            node = node.value
+        if not isinstance(node, ast.Name):
+            return
+
+        if node is target:
+            on_write(node.id, "local")  # 이름 대입은 항상 local
+        else:  # a[0] = 3 → a가 들어있는 스코프
+            on_write(node.id, "global" if node.id in vars_.get("global", {}) else "local")
+
     def _apply_increment(target_expr: str, *, delta: int, is_prefix: bool) -> Any:
         try:
             target = ast.parse(target_expr, mode="eval").body
@@ -245,6 +282,7 @@ def safe_eval_expr(
 
             new_val = _increment_value(cur, delta, target_expr) if exists else delta
             vars_.setdefault("local", {})[name] = new_val
+            _notify_write(target)
             return new_val if is_prefix else cur
 
         if isinstance(target, ast.Subscript):
@@ -256,6 +294,7 @@ def safe_eval_expr(
 
             new_val = _increment_value(cur, delta, target_expr)
             container[key] = new_val
+            _notify_write(target)
             return new_val if is_prefix else cur
 
         raise ValueError("only variable or subscript increment targets are allowed")
@@ -278,11 +317,13 @@ def safe_eval_expr(
     def _set_assign_target_value(target: ast.AST, value: Any) -> Any:
         if isinstance(target, ast.Name):
             vars_.setdefault("local", {})[target.id] = value
+            _notify_write(target)
             return value
 
         if isinstance(target, ast.Subscript):
             container = _eval(target.value)
             container[_eval_subscript_key(target)] = value
+            _notify_write(target)
             return value
 
         raise ValueError("only variable or subscript assignment targets are allowed")
@@ -342,9 +383,9 @@ def safe_eval_expr(
         if is_explicit_expression:
             raise ValueError(f"failed to evaluate expression: {expr}") from None
         return s
-    except Exception:
+    except Exception as e:
         if is_explicit_expression:
-            raise ValueError(f"failed to evaluate expression: {expr}") from None
+            raise ValueError(f"failed to evaluate expression: {expr} ({e})") from e
         return s
 
 
@@ -362,9 +403,68 @@ def _pick_target_loop(func, provided: dict) -> asyncio.AbstractEventLoop | None:
     return None
 
 
+_PYBIND_SIG_RE = re.compile(r"^\w+\((?P<params>.*)\)\s*->")
+
+
+def _split_top_level(src: str) -> list[str]:
+    parts: list[str] = []
+    depth = 0
+    buf: list[str] = []
+    for ch in src:
+        if ch in "([{":
+            depth += 1
+        elif ch in ")]}":
+            depth -= 1
+        if ch == "," and depth == 0:
+            parts.append("".join(buf))
+            buf = []
+        else:
+            buf.append(ch)
+    parts.append("".join(buf))
+    return [p.strip() for p in parts if p.strip()]
+
+
+def _signature_from_pybind_doc(func) -> inspect.Signature | None:
+    """pybind11 함수는 __text_signature__가 없어 inspect.signature가 실패한다.
+    시그니처가 유일하게 남아 있는 __doc__ 첫 줄에서 인자 이름/기본값 유무만 복원한다."""
+    doc = (getattr(func, "__doc__", None) or "").lstrip()
+    match = _PYBIND_SIG_RE.match(doc.splitlines()[0]) if doc else None
+    if match is None:
+        return None
+
+    params: list[inspect.Parameter] = []
+    for token in _split_top_level(match.group("params")):
+        head, _, default = token.partition("=")
+        name = head.split(":", 1)[0].strip()
+
+        if name.startswith("**"):
+            kind, name = inspect.Parameter.VAR_KEYWORD, name[2:]
+        elif name.startswith("*"):
+            kind, name = inspect.Parameter.VAR_POSITIONAL, name[1:]
+        else:
+            kind = inspect.Parameter.KEYWORD_ONLY
+
+        if not name or (name == "self" and not params):
+            continue
+
+        has_default = bool(default.strip()) and kind is inspect.Parameter.KEYWORD_ONLY
+        params.append(
+            inspect.Parameter(
+                name, kind, default=None if has_default else inspect.Parameter.empty
+            )
+        )
+
+    return inspect.Signature(params)
+
+
 def call_with_matching_args(func, **provided):
     """func의 시그니처를 보고 필요한 인자만 추려서 호출 (동기/비동기 모두 지원, 루프 안전)"""
-    sig = inspect.signature(func)
+    try:
+        sig = inspect.signature(func)
+    except ValueError:
+        sig = _signature_from_pybind_doc(func)
+        if sig is None:
+            raise
     call_kwargs = {}
 
     for name, param in sig.parameters.items():
@@ -408,6 +508,7 @@ def eval_value(
     variables: dict[str, dict[str, Any]] | None = None,
     get_global_variable: Callable[[str], Any] | None = None,
     get_var: Callable[..., Any] | None = None,
+    on_write: Callable[[str, str], None] | None = None,
 ) -> Any:
     # 1) 문자열이면 → 기존 safe_eval_expr 호출
     if isinstance(value, str):
@@ -416,26 +517,45 @@ def eval_value(
             variables=variables,
             get_global_variable=get_global_variable,
             get_var=get_var,
+            on_write=on_write,
         )
 
     # 2) 리스트면 → 각 요소를 재귀적으로 평가
     if isinstance(value, list):
         return [
-            eval_value(v, variables=variables, get_global_variable=get_global_variable, get_var=get_var)
+            eval_value(
+                v,
+                variables=variables,
+                get_global_variable=get_global_variable,
+                get_var=get_var,
+                on_write=on_write,
+            )
             for v in value
         ]
 
     # 3) 튜플도 동일
     if isinstance(value, tuple):
         return tuple(
-            eval_value(v, variables=variables, get_global_variable=get_global_variable, get_var=get_var)
+            eval_value(
+                v,
+                variables=variables,
+                get_global_variable=get_global_variable,
+                get_var=get_var,
+                on_write=on_write,
+            )
             for v in value
         )
 
     # 4) 딕셔너리면 → value만 재귀적으로 평가 (key는 그대로)
     if isinstance(value, dict):
         return {
-            k: eval_value(v, variables=variables, get_global_variable=get_global_variable, get_var=get_var)
+            k: eval_value(
+                v,
+                variables=variables,
+                get_global_variable=get_global_variable,
+                get_var=get_var,
+                on_write=on_write,
+            )
             for k, v in value.items()
         }
 

{rainbow_rb_utils-0.0.9.dev45 → rainbow_rb_utils-0.0.73.dev1}/src/rainbow/rb_utils/helper.py

@@ -1,6 +1,7 @@
 import asyncio
 import math
 import socket
+from concurrent.futures import ThreadPoolExecutor
 from typing import Any
 
 from .parser import t_to_dict
@@ -18,23 +19,36 @@ def ManipulateZenohResHelper(obj: Any):
     raise ValueError("obj is not a dict")
 
 
+# 기본 executor 는 쓰지 않는다. wait_for 는 시작된 스레드를 못 죽여서, 여기가
+# 막히면 이 함수를 넘어 MuscatRouter 핸들러까지 같이 굶는다.
+_dns_fallback_pool = ThreadPoolExecutor(max_workers=1, thread_name_prefix="rb-ip-dns")
+
+
+def _route_lookup_ip() -> str | None:
+    """기본 경로로 나가는 인터페이스 IP. 패킷 안 나가고 라우팅 테이블만 본다 (µs)."""
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+            sock.connect(("8.8.8.8", 80))
+            return sock.getsockname()[0]
+    except OSError:
+        return None  # 기본 경로 없음
+
+
 async def get_current_ip(timeout: float = 0.5) -> str:
-    def resolve_ip() -> str:
-        try:
-            with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
-                sock.connect(("8.8.8.8", 80))
-                return sock.getsockname()[0]
-        except Exception:
-            return socket.gethostbyname(socket.gethostname())
+    ip = _route_lookup_ip()
+    if ip is not None:
+        return ip
 
+    # 기본 경로가 없을 때만. 호스트명 해석은 DNS 를 탈 수 있다.
     loop = asyncio.get_running_loop()
     try:
         return await asyncio.wait_for(
-            loop.run_in_executor(None, resolve_ip),
+            loop.run_in_executor(
+                _dns_fallback_pool, lambda: socket.gethostbyname(socket.gethostname())
+            ),
             timeout=timeout,
         )
-    except Exception:
-        # DNS가 막히면 이전 IP를 쓰거나, 로컬 IP로 폴백
+    except (TimeoutError, OSError):
         return "127.0.0.1"
 
 

{rainbow_rb_utils-0.0.9.dev45 → rainbow_rb_utils-0.0.73.dev1}/src/rainbow/rb_utils/manipulate.py

@@ -79,6 +79,9 @@ def validate_single_return_value(res: QueryResult[T], fm_args: FlowManagerArgs |
 
     obj_payload = res.get("obj_payload", None)
     if obj_payload is None:
+        err = res.get("err")
+        if err:
+            raise RuntimeError(f"{snake_to_title(call_function)} failed: {err}")
         raise RuntimeError(f"{snake_to_title(call_function)} failed: obj_payload is None")
 
     if hasattr(obj_payload, "returnValue") and obj_payload.returnValue != 0:

rainbow_rb_utils-0.0.73.dev1/src/rainbow/rb_utils/program.py

@@ -0,0 +1,135 @@
+import ipaddress
+from typing import Any, Literal
+
+
+def get_task_id(args: Any | None) -> str:
+    if not args:
+        return "unknown_module"
+
+    # FlowManagerArgs 객체와 dict 입력을 모두 허용한다.
+    ctx = args.get("ctx") if isinstance(args, dict) else getattr(args, "ctx", None)
+
+    process_id = getattr(ctx, "process_id", None)
+    return str(process_id) if process_id else "unknown_module"
+
+
+_MISSING = object()
+
+_RESOLVE_OPTIONS = ("SKIP", "STOP", "ASK")
+
+
+class InterfaceResult:
+    def __init__(self, success: bool, error: str | None = None):
+        self.success = success
+        self.error = error
+
+    def __str__(self) -> str:
+        if self.error:
+            return self.error
+        return "success" if self.success else "The request failed."
+
+
+def to_int(
+    data_or_value,
+    field_name: str | None = None,
+    default: int | object = _MISSING,
+    error_prefix: str | None = None,
+) -> int:
+    """값을 int로 변환하고, default가 있을 때만 None/빈 문자열을 대체한다."""
+
+    def _raise(msg: str) -> None:
+        if error_prefix:
+            raise ValueError(f"{error_prefix}: {msg}")
+        raise ValueError(msg)
+
+    if field_name is not None and hasattr(data_or_value, "get"):
+        value = data_or_value.get(field_name)
+        name = field_name
+    else:
+        value = data_or_value
+        name = field_name or "value"
+
+    if value is None or value == "":
+        if default is _MISSING:
+            _raise(f"failed: {name} is required")
+        return int(default)
+    try:
+        return int(value)
+    except (TypeError, ValueError) as exc:
+        if error_prefix:
+            raise ValueError(
+                f"{error_prefix}: failed: int conversion failed {name}={value}"
+            ) from exc
+        raise ValueError(f"failed: int conversion failed {name}={value}") from exc
+
+
+def validate_server_ip(data, error_prefix: str) -> str:
+    server_ip = data.get("server_ip")
+
+    if server_ip in (None, "", Ellipsis):
+        raise ValueError(f"{error_prefix}: server_ip is required")
+
+    if not isinstance(server_ip, str):
+        raise ValueError(f"{error_prefix}: server_ip must be a string")
+
+    server_ip = server_ip.strip()
+    if not server_ip:
+        raise ValueError(f"{error_prefix}: server_ip is required")
+
+    try:
+        ipaddress.ip_address(server_ip)
+    except ValueError as exc:
+        raise ValueError(f"{error_prefix}: invalid server_ip={server_ip}") from exc
+
+    return server_ip
+
+
+def get_resolve_option(data, error_prefix: str) -> str:
+    value = data.get("resolve_option", "SKIP")
+    if value not in _RESOLVE_OPTIONS:
+        raise ValueError(
+            f"{error_prefix}: invalid resolve_option={value!r} (allowed: {_RESOLVE_OPTIONS})"
+        )
+    return value
+
+
+def get_timeout_sec(data, error_prefix: str, default: float | None = None) -> int:
+    value = data.get("timeout_sec")
+    if value is None or value == "":
+        if default is None:
+            raise ValueError(f"{error_prefix}: timeout_sec is required")
+        return int(default * 1000)
+    try:
+        return int(float(value) * 1000)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(
+            f"{error_prefix}: failed: timeout_sec conversion failed value={value}"
+        ) from exc
+
+
+def get_required_field(data, field_name: str, error_prefix: str):
+    value = data.get(field_name)
+    if value in (None, "", Ellipsis):
+        raise ValueError(f"{error_prefix}: {field_name} is required")
+    return value
+
+
+def resolve_interface_flow(
+    result,
+    resolve_option: Literal["SKIP", "STOP", "ASK"],
+    flow_manager_args,
+    alarm_fn=None,
+    error_prefix: str = "Interface",
+):
+    err_msg = getattr(result, "error", None)
+    if err_msg in (None, ""):
+        err_msg = str(result) if result not in (None, False) else "The request failed."
+    if resolve_option == "ASK" and alarm_fn is not None:
+        alarm_fn(title="Interface Debug", content=f"{error_prefix}.(Err:{err_msg})")
+        flow_manager_args.ctx.pause_all()
+        flow_manager_args.ctx.pause()
+        flow_manager_args.ctx.check_stop()
+    elif resolve_option == "STOP":
+        raise RuntimeError(f"{error_prefix}: result={err_msg}")
+    else:
+        pass  # SKIP: do nothing and continue

{rainbow_rb_utils-0.0.9.dev45 → rainbow_rb_utils-0.0.73.dev1}/src/rainbow_rb_utils.egg-info/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: rainbow-rb-utils
-Version: 0.0.9.dev45
+Version: 0.0.73.dev1
 Summary: Rainbow Python Utilities
 Author-email: Derek <dfd1123@rainbow-robotics.com>
-Requires-Python: >=3.11
+Requires-Python: <3.14,>=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: psutil<8.0.0,>=7.0.0
-Requires-Dist: rainbow-rb-log==0.0.9.dev45
+Requires-Dist: rainbow-rb-log==0.0.73.dev1
 
 # rb_utils
 

{rainbow_rb_utils-0.0.9.dev45 → rainbow_rb_utils-0.0.73.dev1}/src/rainbow_rb_utils.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ src/rainbow/rb_utils/asyncio_helper.py
 src/rainbow/rb_utils/date.py
 src/rainbow/rb_utils/env.py
 src/rainbow/rb_utils/file.py
+src/rainbow/rb_utils/flatbuffer.py
 src/rainbow/rb_utils/flow_manager.py
 src/rainbow/rb_utils/helper.py
 src/rainbow/rb_utils/manipulate.py

rainbow_rb_utils-0.0.73.dev1/src/rainbow_rb_utils.egg-info/requires.txt

@@ -0,0 +1,2 @@
+psutil<8.0.0,>=7.0.0
+rainbow-rb-log==0.0.73.dev1

rainbow_rb_utils-0.0.9.dev45/src/rainbow/rb_utils/program.py

@@ -1,12 +0,0 @@
-from typing import Any
-
-
-def get_task_id(args: Any | None) -> str:
-    if not args:
-        return "unknown_module"
-
-    # FlowManagerArgs 객체와 dict 입력을 모두 허용한다.
-    ctx = args.get("ctx") if isinstance(args, dict) else getattr(args, "ctx", None)
-
-    process_id = getattr(ctx, "process_id", None)
-    return str(process_id) if process_id else "unknown_module"

rainbow_rb_utils-0.0.9.dev45/src/rainbow_rb_utils.egg-info/requires.txt

@@ -1,2 +0,0 @@
-psutil<8.0.0,>=7.0.0
-rainbow-rb-log==0.0.9.dev45