rainbow-rb-utils 0.0.9.dev5__py3-none-any.whl

rainbow/rb_utils/flow_manager.py

@@ -0,0 +1,400 @@
+import ast
+import asyncio
+import builtins
+import inspect
+import math
+import operator
+import re
+from collections.abc import Callable, Coroutine
+from concurrent.futures import Future
+from typing import Any
+
+# --- 간단 테이블 (함수/상수/연산자) -----------------------------------------
+BIN_OPS = {
+    ast.Add: operator.add,
+    ast.Sub: operator.sub,
+    ast.Mult: operator.mul,
+    ast.Div: operator.truediv,
+    ast.FloorDiv: operator.floordiv,
+    ast.Pow: operator.pow,
+    ast.Mod: operator.mod,
+}
+UNARY_OPS: dict[type[ast.unaryop], Callable] = {ast.USub: operator.neg, ast.UAdd: operator.pos}
+CMP_OPS: dict[type[ast.cmpop], Callable] = {
+    ast.Eq: operator.eq,
+    ast.NotEq: operator.ne,
+    ast.Lt: operator.lt,
+    ast.LtE: operator.le,
+    ast.Gt: operator.gt,
+    ast.GtE: operator.ge,
+}
+ALLOWED_FUNCS = {
+    "sin": math.sin,
+    "cos": math.cos,
+    "tan": math.tan,
+    "sqrt": math.sqrt,
+    "log": math.log,
+    "log10": math.log10,
+    "exp": math.exp,
+    "abs": abs,
+    "max": max,
+    "min": min,
+    "pow": pow,
+    "sum": sum,
+    "round": round,
+    "int": int,
+    "float": float,
+    "str": str,
+    "len": len,
+    "range": range,
+}
+ALLOWED_CALLABLES = set(ALLOWED_FUNCS.values())
+ALLOWED_CONSTS = {
+    "pi": math.pi,
+    "e": math.e,
+    "tau": getattr(math, "tau", 2 * math.pi),
+    "inf": math.inf,
+    "nan": math.nan,
+}
+
+EXPLICIT_EXPR_PATTERN = re.compile(r"\$[A-Za-z_]\w*")
+RB_GLOBAL_PATTERN = re.compile(r"\bRB_[A-Za-z_0-9]*\b")
+
+
+def safe_eval_expr(
+    expr: Any,
+    variables: dict[str, dict[str, Any]] | None = None,
+    get_global_variable: Callable[[str], Any] | None = None,
+) -> Any:
+    if not isinstance(expr, str):
+        return expr
+
+    vars_ = variables or {"local": {}}
+    s = expr.strip()
+    if not s:
+        return ""
+
+    is_explicit_expression = bool(EXPLICIT_EXPR_PATTERN.search(s) or RB_GLOBAL_PATTERN.search(s))
+    normalized = EXPLICIT_EXPR_PATTERN.sub(lambda match: match.group()[1:], s)
+
+    # --- 증감(식 전체일 때만 허용) ---------------------------------------------
+    inc_post = re.match(r"^([A-Za-z_]\w*)\s*\+\+$", s)  # a++
+    dec_post = re.match(r"^([A-Za-z_]\w*)\s*--$", s)  # a--
+    inc_pre = re.match(r"^\+\+\s*([A-Za-z_]\w*)$", s)  # ++a
+    dec_pre = re.match(r"^--\s*([A-Za-z_]\w*)$", s)  # --a
+    match = inc_post or dec_post or inc_pre or dec_pre
+    if match:
+        name = match.group(1)
+        exists = name in vars_.get("local", {}) or name in vars_.get("global", {})
+        cur: int | None = (
+            vars_.get("local", {}).get(name)
+            if name in vars_.get("local", {})
+            else vars_.get("global", {}).get(name, 0)
+        )
+
+        if cur is None:
+            raise ValueError(f"variable {name} not found")
+
+        if inc_post:
+            vars_.setdefault("local", {})[name] = cur + 1 if exists else 1
+            return cur
+        if dec_post:
+            vars_.setdefault("local", {})[name] = cur - 1 if exists else -1
+            return cur
+        if inc_pre:
+            v = cur + 1 if exists else 1
+            vars_.setdefault("local", {})[name] = v
+            return v
+        if dec_pre:
+            v = cur - 1 if exists else -1
+            vars_.setdefault("local", {})[name] = v
+            return v
+
+    # --- 내부 평가기 ------------------------------------------------------------
+    def _eval(node: ast.AST) -> Any:
+        if isinstance(node, ast.Constant):
+            return node.value
+
+        if isinstance(node, ast.Name):
+            name = node.id
+            if name == "true":
+                return True
+            if name == "false":
+                return False
+            if name == "null":
+                return None
+            if name in ALLOWED_FUNCS:  # 함수 이름
+                return ALLOWED_FUNCS[name]
+            if name in ALLOWED_CONSTS:  # 수학 상수
+                return ALLOWED_CONSTS[name]
+            if name == "math":  # math.* 전용
+                return "math"
+            if name in vars_.get("local", {}):
+                return vars_["local"].get(name)
+
+            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
+                raise ValueError(f"global variable {name} not found")
+
+            return name  # 모르는 식별자는 문자열로 취급(원하면 여기서 NameError)
+
+        if isinstance(node, ast.Attribute):
+            base = _eval(node.value)
+            attr = node.attr
+            if isinstance(base, dict) and attr in base:
+                return base[attr]
+            if base == "math":
+                if attr in ALLOWED_CONSTS:
+                    return ALLOWED_CONSTS[attr]
+                if attr in ALLOWED_FUNCS and hasattr(math, attr):
+                    return getattr(math, attr)
+                raise ValueError(f"unknown math attribute: {attr}")
+            raise ValueError(f"attribute access not allowed: {type(base).__name__}.{attr}")
+
+        if isinstance(node, ast.Subscript):
+            seq = _eval(node.value)
+            sl = node.slice
+            if isinstance(sl, ast.Slice):
+                lo = _eval(sl.lower) if sl.lower else None
+                up = _eval(sl.upper) if sl.upper else None
+                st = _eval(sl.step) if sl.step else None
+                return seq[slice(lo, up, st)]
+            return seq[_eval(sl)]
+
+        if isinstance(node, ast.BinOp):
+            try:
+                bin_fn = BIN_OPS[type(node.op)]  # get() 쓰지 말고 [] 사용 → Optional 제거
+            except KeyError:
+                raise ValueError(f"unsupported operator: {type(node.op)}") from None
+            return bin_fn(_eval(node.left), _eval(node.right))
+
+        if isinstance(node, ast.UnaryOp):
+            try:
+                un_fn = UNARY_OPS[type(node.op)]  # 변수명 분리(= 타입 분리)
+            except KeyError:
+                raise ValueError(f"unsupported unary operator: {type(node.op)}") from None
+            return un_fn(_eval(node.operand))
+
+        if isinstance(node, ast.Compare):
+            left = _eval(node.left)
+            for op, comp in zip(node.ops, node.comparators, strict=False):  # strict 인자 빼
+                try:
+                    cmp_fn = CMP_OPS[type(op)]  # Optional 제거
+                except KeyError:
+                    raise ValueError(f"unsupported comparison: {type(op)}") from None
+                right = _eval(comp)
+                if not cmp_fn(left, right):
+                    return False
+                left = right
+            return True
+
+        if isinstance(node, ast.BoolOp):
+            if isinstance(node.op, ast.And):
+                return all(_eval(v) for v in node.values)
+            if isinstance(node.op, ast.Or):
+                return any(_eval(v) for v in node.values)
+
+        if isinstance(node, ast.Call):
+            fn = _eval(node.func)
+            if fn not in ALLOWED_CALLABLES:
+                raise ValueError(f"function not allowed: {fn}")
+            if node.keywords:
+                raise ValueError("keyword arguments not allowed")
+            args = [_eval(a) for a in node.args]
+            return fn(*args)
+
+        if isinstance(node, ast.List):
+            return [_eval(e) for e in node.elts]
+        if isinstance(node, ast.Tuple):
+            return tuple(_eval(e) for e in node.elts)
+        if isinstance(node, ast.Dict):
+            return {
+                (_eval(k) if k is not None else None): _eval(v)
+                for k, v in zip(node.keys, node.values, strict=False)
+            }
+
+        if isinstance(node, ast.IfExp):
+            return _eval(node.body) if _eval(node.test) else _eval(node.orelse)
+
+        raise ValueError(f"unsupported expression: {ast.dump(node)}")
+
+    # --- 단순 대입: a = <expr> (한 문장만 허용) ---------------------------------
+    try:
+        mod = ast.parse(normalized, mode="exec")
+        if len(mod.body) == 1:
+            stmt = mod.body[0]
+
+            # 1) 단순 대입: a = <expr>
+            if isinstance(stmt, ast.Assign):
+                tgt = stmt.targets[0]
+                if not isinstance(tgt, ast.Name):
+                    raise ValueError("only simple assignment like `a = <expr>` is allowed")
+                val = _eval(stmt.value)
+                vars_.setdefault("local", {})[tgt.id] = val
+                return val
+
+            # 2) 복합 대입: a *= <expr>  (+=, -=, /= ... 포함)
+            if isinstance(stmt, ast.AugAssign):
+                if not isinstance(stmt.target, ast.Name):
+                    raise ValueError("only simple aug assignment like `a *= <expr>` is allowed")
+
+                name = stmt.target.id
+
+                # 현재값 가져오기 (local 우선, 없으면 global, 그래도 없으면 0)
+                if name in vars_.get("local", {}):
+                    cur = vars_["local"][name]
+                elif name in vars_.get("global", {}):
+                    cur = vars_["global"][name]
+                else:
+                    cur = 0
+
+                try:
+                    bin_fn = BIN_OPS[type(stmt.op)]
+                except KeyError:
+                    raise ValueError(
+                        f"unsupported operator in aug-assign: {type(stmt.op)}"
+                    ) from None
+
+                rhs = _eval(stmt.value)
+                new_val = bin_fn(cur, rhs)
+
+                # 로컬에 기록(네 증감 로직이랑 일관되게)
+                vars_.setdefault("local", {})[name] = new_val
+                return new_val
+    except SyntaxError:
+        pass  # 표현식일 수 있으니 아래로 진행
+    except Exception as e:
+        raise e
+
+    # --- 일반 표현식 ------------------------------------------------------------
+    try:
+        tree = ast.parse(normalized, mode="eval")
+        return _eval(tree.body)
+    except SyntaxError:
+        if is_explicit_expression:
+            raise ValueError(f"failed to evaluate expression: {expr}") from None
+        return s
+    except Exception:
+        if is_explicit_expression:
+            raise ValueError(f"failed to evaluate expression: {expr}") from None
+        return s
+
+
+def _pick_target_loop(func, provided: dict) -> asyncio.AbstractEventLoop | None:
+    bound_self = getattr(func, "__self__", None)
+    if bound_self is not None:
+        loop = getattr(bound_self, "loop", None)
+        if isinstance(loop, asyncio.AbstractEventLoop):
+            return loop
+
+    loop = provided.get("loop")
+    if isinstance(loop, asyncio.AbstractEventLoop):
+        return loop
+
+    return None
+
+
+def call_with_matching_args(func, **provided):
+    """func의 시그니처를 보고 필요한 인자만 추려서 호출 (동기/비동기 모두 지원, 루프 안전)"""
+    sig = inspect.signature(func)
+    call_kwargs = {}
+
+    for name, param in sig.parameters.items():
+        if name in provided:
+            call_kwargs[name] = provided[name]
+        elif param.default is inspect.Parameter.empty and param.kind not in (
+            inspect.Parameter.VAR_POSITIONAL,
+            inspect.Parameter.VAR_KEYWORD,
+        ):
+            raise TypeError(f"Missing required parameter: {name}")
+
+    result: Any = func(**call_kwargs)
+
+    async def _await_awaitable(a):
+        return await a
+
+    if inspect.isawaitable(result):
+        target_loop = _pick_target_loop(func, provided)
+
+        if target_loop is not None:
+            coro: Coroutine[Any, Any, Any] = (
+                result if inspect.iscoroutine(result) else _await_awaitable(result)
+            )
+            future: Future[Any] = asyncio.run_coroutine_threadsafe(coro, target_loop)
+            return future.result()
+
+        try:
+            running = asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(_await_awaitable(result))
+
+        task: asyncio.Task = running.create_task(_await_awaitable(result))
+        return task
+
+    # 3) 동기 함수면 결과 그대로 반환
+    return result
+
+
+def eval_value(
+    value: Any,
+    variables: dict[str, dict[str, Any]] | None = None,
+    get_global_variable: Callable[[str], Any] | None = None,
+) -> Any:
+    # 1) 문자열이면 → 기존 safe_eval_expr 호출
+    if isinstance(value, str):
+        return safe_eval_expr(
+            value,
+            variables=variables,
+            get_global_variable=get_global_variable,
+        )
+
+    # 2) 리스트면 → 각 요소를 재귀적으로 평가
+    if isinstance(value, list):
+        return [
+            eval_value(v, variables=variables, get_global_variable=get_global_variable)
+            for v in value
+        ]
+
+    # 3) 튜플도 동일
+    if isinstance(value, tuple):
+        return tuple(
+            eval_value(v, variables=variables, get_global_variable=get_global_variable)
+            for v in value
+        )
+
+    # 4) 딕셔너리면 → value만 재귀적으로 평가 (key는 그대로)
+    if isinstance(value, dict):
+        return {
+            k: eval_value(v, variables=variables, get_global_variable=get_global_variable)
+            for k, v in value.items()
+        }
+
+    # 5) 나머지(int/float/bool/None 등)는 그대로
+    return value
+
+
+DENY_BUILTINS = {
+    "__import__",  # import 막기 (이거 열리면 끝)
+    "open",  # 파일 접근
+    "input",  # 서버에서 대기 위험
+    "eval",
+    "exec",
+    "compile",  # 자기 실행 계열
+    "globals",
+    "locals",
+    "vars",  # 탐색/우회 보조
+    "breakpoint",  # 디버거
+}
+
+
+def make_builtins_allow_most():
+    """위험하지 않은 모든 내장 함수를 허용하는 딕셔너리를 생성"""
+    safe = dict(builtins.__dict__)
+
+    for k in list(safe.keys()):
+        if k in DENY_BUILTINS:
+            safe.pop(k, None)
+
+    return safe

rainbow/rb_utils/helper.py

@@ -0,0 +1,28 @@
+import asyncio
+import socket
+from typing import Any
+
+from .parser import t_to_dict
+
+
+def ManipulateZenohResHelper(obj: Any):
+    dict_obj = t_to_dict(obj)
+
+    if dict_obj.hasAttr("returnValue"):
+        dict_obj.set("return_value", dict_obj.get("returnValue"))
+        del dict_obj["returnValue"]
+
+    raise ValueError("obj is not a dict")
+
+
+async def get_current_ip(timeout: float = 0.5) -> str:
+    hostname = socket.gethostname()
+    loop = asyncio.get_running_loop()
+    try:
+        return await asyncio.wait_for(
+            loop.run_in_executor(None, socket.gethostbyname, hostname),
+            timeout=timeout,
+        )
+    except Exception:
+        # DNS가 막히면 이전 IP를 쓰거나, 로컬 IP로 폴백
+        return "127.0.0.1"

rainbow/rb_utils/manipulate.py

@@ -0,0 +1,202 @@
+import inspect
+
+from rainbow.rb_flat_buffers.IPC.State_Core import State_Core
+from rainbow.rb_log.log import rb_log
+from rainbow.rb_schemas.sdk import FlowManagerArgs
+from rainbow.rb_zenoh.client import QueryAllResult, QueryResult, T
+
+
+def snake_to_title(s: str) -> str:
+    return s.replace("_", " ").title()
+
+
+def validate_payload(results: list[QueryAllResult], /, fm_args: FlowManagerArgs | None = None):
+    """
+    반환된 객체 리스트에서 obj_payload 필드가 None인 경우 예외를 던진다.
+
+    Args:
+        results: 반환된 객체 리스트 (obj_payload 필드가 있는지 확인)
+    """
+
+    if fm_args is None:
+        return
+
+    call_function = inspect.stack()[1].function
+
+    for result in results:
+        obj_payload = result.get("obj_payload", None)
+        key = result.get("key", "unknown_key")
+        if obj_payload is None:
+            raise RuntimeError(
+                f"{snake_to_title(call_function)} failed[{key}]: obj_payload is None"
+            )
+
+
+def validate_multi_return_value(
+    results: list[QueryAllResult],
+    /,
+    title: str | None = None,
+    fm_args: FlowManagerArgs | None = None,
+):
+    """
+    PyFM이 실행할 경우 obj_payload에 returnValue 필드가 있고, 0이 아니면 에러로 간주해서 로그 남기고 예외를 던진다.
+
+    Args:
+        obj_payload: 반환된 객체 (returnValue 필드가 있는지 확인)
+        key: 키 값 (로그용)
+    """
+    if fm_args is None:
+        return
+
+    call_function = inspect.stack()[1].function
+
+    for result in results:
+        obj_payload = result.get("obj_payload", None)
+        key = result.get("key", "unknown_key")
+        if obj_payload is None:
+            raise RuntimeError(
+                f"{title if title is not None else snake_to_title(call_function)} failed[{key}]: obj_payload is None"
+            )
+
+        if hasattr(obj_payload, "returnValue") and obj_payload.returnValue != 0:
+            error_msg = f"[{call_function}] return value is {obj_payload.returnValue}"
+            if key is not None:
+                error_msg = f"[{call_function}] [{key}] return value is {obj_payload.returnValue}"
+            rb_log.error(error_msg)
+            raise RuntimeError(error_msg)
+
+
+def validate_single_return_value(res: QueryResult[T], fm_args: FlowManagerArgs | None = None) -> T:
+    """
+    PyFM이 실행할 경우 obj_payload에 returnValue 필드가 있고, 0이 아니면 에러로 간주해서 로그 남기고 예외를 던진다.
+
+    Args:
+        res: query_one 결과 객체
+        key: 키 값 (로그용)
+    """
+
+    call_function = inspect.stack()[1].function
+
+    obj_payload = res.get("obj_payload", None)
+    if obj_payload is None:
+        raise RuntimeError(f"{snake_to_title(call_function)} failed: obj_payload is None")
+
+    if hasattr(obj_payload, "returnValue") and obj_payload.returnValue != 0:
+        error_msg = f"[{call_function}] return value is {obj_payload.returnValue}"
+        raise RuntimeError(error_msg)
+
+    if fm_args is not None:
+        fm_args.done()
+
+    return obj_payload
+
+
+def parse_state_core_mv_to_dict(mv: memoryview) -> dict[str, object]:
+    """
+    State_Core 메모리뷰를 딕셔너리로 변환
+    Args:
+        mv: State_Core 메모리뷰
+
+    Returns:
+        dict[str, object]: State_Core 메모리뷰를 딕셔너리로 변환
+    """
+
+    def _numpy_or_list_to_list(values) -> list[float | int]:
+        return values.tolist() if hasattr(values, "tolist") else list(values)
+
+    def _parse_string(value) -> str | None:
+        if value is None:
+            return None
+        if isinstance(value, memoryview):
+            value = bytes(value)
+        if isinstance(value, bytes | bytearray):
+            return bytes(value).decode("utf-8", "ignore")
+        return str(value)
+
+    def _parse_float_array_struct(obj: object) -> dict | None:
+        if obj is None:
+            return None
+        values = obj.FAsNumpy() if hasattr(obj, "FAsNumpy") else obj.F()
+        return {"f": _numpy_or_list_to_list(values)}
+
+    def _parse_uint_array_struct(obj: object) -> dict | None:
+        if obj is None:
+            return None
+        values = obj.UAsNumpy() if hasattr(obj, "UAsNumpy") else obj.U()
+        return {"u": _numpy_or_list_to_list(values)}
+
+    obj = State_Core.GetRootAs(mv, 0)
+
+    return {
+        "heartBeat": obj.HeartBeat(),
+        "timestampUsecMono": obj.TimestampUsecMono(),
+        "jointQRef": _parse_float_array_struct(obj.JointQRef()),
+        "jointQEnc": _parse_float_array_struct(obj.JointQEnc()),
+        "jointTEsti": _parse_float_array_struct(obj.JointTEsti()),
+        "jointTMeas": _parse_float_array_struct(obj.JointTMeas()),
+        "jointTemper": _parse_float_array_struct(obj.JointTemper()),
+        "carteXRef": _parse_float_array_struct(obj.CarteXRef()),
+        "carteXEnc": _parse_float_array_struct(obj.CarteXEnc()),
+        "carteSpeedRef": _parse_float_array_struct(obj.CarteSpeedRef()),
+        "carteSpeedEnc": _parse_float_array_struct(obj.CarteSpeedEnc()),
+        "userfSelectionNo": obj.UserfSelectionNo(),
+        "userfXRef": _parse_float_array_struct(obj.UserfXRef()),
+        "toolSelectionNo": obj.ToolSelectionNo(),
+        "toolName": _parse_string(obj.ToolName()),
+        "toolTcpX": obj.ToolTcpX(),
+        "toolTcpY": obj.ToolTcpY(),
+        "toolTcpZ": obj.ToolTcpZ(),
+        "toolTcpRx": obj.ToolTcpRx(),
+        "toolTcpRy": obj.ToolTcpRy(),
+        "toolTcpRz": obj.ToolTcpRz(),
+        "toolComM": obj.ToolComM(),
+        "toolComX": obj.ToolComX(),
+        "toolComY": obj.ToolComY(),
+        "toolComZ": obj.ToolComZ(),
+        "cboxDigitalInput": _parse_uint_array_struct(obj.CboxDigitalInput()),
+        "cboxDigitalOutput": _parse_uint_array_struct(obj.CboxDigitalOutput()),
+        "cboxAnalogInput": _parse_float_array_struct(obj.CboxAnalogInput()),
+        "cboxAnalogOutput": _parse_float_array_struct(obj.CboxAnalogOutput()),
+        "exDigitalInput": _parse_uint_array_struct(obj.ExDigitalInput()),
+        "exDigitalOutput": _parse_uint_array_struct(obj.ExDigitalOutput()),
+        "exAnalogInput": _parse_float_array_struct(obj.ExAnalogInput()),
+        "exAnalogOutput": _parse_float_array_struct(obj.ExAnalogOutput()),
+        "toolDigitalInput": _parse_uint_array_struct(obj.ToolDigitalInput()),
+        "toolDigitalOutput": _parse_uint_array_struct(obj.ToolDigitalOutput()),
+        "toolAnalogInput": _parse_float_array_struct(obj.ToolAnalogInput()),
+        "toolAnalogOutput": _parse_float_array_struct(obj.ToolAnalogOutput()),
+        "toolVoltageOutput": obj.ToolVoltageOutput(),
+        "motionMode": obj.MotionMode(),
+        "motionExecutionResult": obj.MotionExecutionResult(),
+        "motionSpeedBar": obj.MotionSpeedBar(),
+        "motionIsPause": obj.MotionIsPause(),
+        "statusLan2can": obj.StatusLan2can(),
+        "statusSwitchEmg": obj.StatusSwitchEmg(),
+        "statusPowerOut": obj.StatusPowerOut(),
+        "statusServoNum": obj.StatusServoNum(),
+        "statusIsRefon": obj.StatusIsRefon(),
+        "statusOutColl": obj.StatusOutColl(),
+        "statusSelfColl": obj.StatusSelfColl(),
+        "statusDtMode": obj.StatusDtMode(),
+        "statusPyfmState": obj.StatusPyfmState(),
+        "forcetorqueExtX": obj.ForcetorqueExtX(),
+        "forcetorqueExtY": obj.ForcetorqueExtY(),
+        "forcetorqueExtZ": obj.ForcetorqueExtZ(),
+        "forcetorqueExtRx": obj.ForcetorqueExtRx(),
+        "forcetorqueExtRy": obj.ForcetorqueExtRy(),
+        "forcetorqueExtRz": obj.ForcetorqueExtRz(),
+        "forcetorqueIntX": obj.ForcetorqueIntX(),
+        "forcetorqueIntY": obj.ForcetorqueIntY(),
+        "forcetorqueIntZ": obj.ForcetorqueIntZ(),
+        "forcetorqueIntRx": obj.ForcetorqueIntRx(),
+        "forcetorqueIntRy": obj.ForcetorqueIntRy(),
+        "forcetorqueIntRz": obj.ForcetorqueIntRz(),
+        "weldInfoTxChunk": obj.WeldInfoTxChunk(),
+        "weldInfoTxCurrent": obj.WeldInfoTxCurrent(),
+        "weldInfoTxVoltage": obj.WeldInfoTxVoltage(),
+        "weldInfoTxFeedrate": obj.WeldInfoTxFeedrate(),
+        "weldInfoRxChunk": obj.WeldInfoRxChunk(),
+        "weldInfoRxCurrent": obj.WeldInfoRxCurrent(),
+        "weldInfoRxVoltage": obj.WeldInfoRxVoltage(),
+        "weldInfoRxFeedrate": obj.WeldInfoRxFeedrate(),
+    }

rainbow/rb_utils/pagination.py

@@ -0,0 +1,38 @@
+"""
+[페이지네이션 응답 타입]
+"""
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class RequestPagination(BaseModel):
+    pageNo: int = Field(1, example=1)
+    pageSize: int = Field(10, example=10)
+    searchText: str = Field("", example="")
+    sortOption: str = Field("createdAt", example="createdAt")
+    sortDirection: Literal["ASC", "DESC"] | None = Field(None, example="ASC")
+
+    def get_offset(self) -> int:
+        # if self.pageNo is None or self.pageNo < 1:
+        #     self.pageNo = 1
+        # if self.pageSize is None or self.pageSize < 1:
+        #     self.pageSize = 10
+        return (self.pageNo - 1) * self.pageSize
+
+    def get_limit(self) -> int:
+        # if self.pageSize is None or self.pageSize < 1:
+        #     self.pageSize = 10
+        return self.pageSize
+
+class ResponsePagination(RequestPagination):
+    totalSize: int
+    totalPage: int
+
+class ResponsePaginationPD(BaseModel):
+    """
+    - items: 아이템 목록
+    - pageInfo: 페이지 정보
+    """
+    items: list[dict]
+    pageInfo: ResponsePagination