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

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: rainbow-rb-utils
-Version: 0.0.9.dev45
+Version: 0.0.73
 Summary: Rainbow Python Utilities
 Author-email: Derek <dfd1123@rainbow-robotics.com>
 Requires-Python: >=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
 
 # rb_utils
 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rainbow-rb-utils"
-version = "0.0.9.dev45"
+version = "0.0.73"
 requires-python = ">=3.11"
 description = "Rainbow Python Utilities"
 authors = [
@@ -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",
 ]
 
 [tool.setuptools]

rainbow_rb_utils-0.0.73/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}/src/rainbow/rb_utils/flow_manager.py

@@ -88,7 +88,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)
 
     # --- 내부 평가기 ------------------------------------------------------------
@@ -118,8 +120,13 @@ def safe_eval_expr(
             if name in vars_.get("local", {}):
                 return vars_["local"].get(name)
 
+            if name in vars_.get("global", {}):
+                return vars_["global"].get(name)
+
             if name.startswith("RB_"):
+                print("eval_value : RB_ started", name)
                 global_val = get_global_variable(name) if get_global_variable is not None else None
+                print("eval_value : ", global_val, name)
                 if global_val is not None:
                     return global_val
                 raise ValueError(f"global variable {name} not found")
@@ -187,7 +194,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:
@@ -421,21 +430,27 @@ def eval_value(
     # 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
+            )
             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
+            )
             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
+            )
             for k, v in value.items()
         }
 

{rainbow_rb_utils-0.0.9.dev45 → rainbow_rb_utils-0.0.73}/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.73/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}/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
 Summary: Rainbow Python Utilities
 Author-email: Derek <dfd1123@rainbow-robotics.com>
 Requires-Python: >=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
 
 # rb_utils
 

{rainbow_rb_utils-0.0.9.dev45 → rainbow_rb_utils-0.0.73}/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/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

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