antioch-py 2.0.7__py3-none-any.whl → 2.2.1__py3-none-any.whl

antioch/session/scene.py

@@ -1,8 +1,7 @@
 from typing import Literal, overload
 
 from antioch.session.ark import Ark
-from antioch.session.session import SessionContainer
-from antioch.session.views import (
+from antioch.session.objects import (
     Animation,
     Articulation,
     BasisCurve,
@@ -20,43 +19,40 @@ from antioch.session.views import (
     has_collision,
     remove_collision,
     set_collision,
-    set_nonvisual_material,
     set_pir_material,
 )
+from antioch.session.session import SessionContainer
 from common.core import ContainerSource, get_asset_path
 from common.core.agent import Agent
 from common.message import Pose, Vector3
-from common.session.environment import SessionEnvironment
-from common.session.sim import (
-    AddAsset,
-    GetPrimAttribute,
-    PrimAttributeValue,
-    QueryScene,
-    SceneQueryResponse,
-    SceneTarget,
-    SetPrimAttribute,
-    SetSimulationControls,
-    SimulationInfo,
-    SimulationTime,
-    Step,
-    ToggleUi,
+from common.session.config import (
+    ArticulationConfig,
+    ArticulationJointConfig,
+    BodyType,
+    CameraConfig,
+    CameraMode,
+    DistortionModel,
+    GeometryConfig,
+    GeometryType,
+    GroundPlaneConfig,
+    ImuConfig,
+    JointAxis,
+    JointConfig,
+    JointType,
+    LightConfig,
+    LightType,
+    MeshApproximation,
+    PirSensorConfig,
+    RadarConfig,
+    RigidBodyConfig,
 )
-from common.session.views.articulation import ArticulationConfig, ArticulationJointConfig
-from common.session.views.camera import CameraConfig, CameraMode, DistortionModel
-from common.session.views.geometry import GeometryConfig, GeometryType, MeshApproximation  # noqa: F401
-from common.session.views.ground_plane import GroundPlaneConfig
-from common.session.views.imu import ImuConfig
-from common.session.views.joint import JointAxis, JointConfig, JointType
-from common.session.views.light import LightConfig, LightType
-from common.session.views.pir_sensor import PirSensorConfig
-from common.session.views.radar import RadarConfig
-from common.session.views.rigid_body import BodyType, RigidBodyConfig
-from common.session.views.viewport import SetActiveViewportCamera, SetCameraView
+from common.session.environment import SessionEnvironment
+from common.session.sim import PrimAttributeValue, SceneQueryResponse, SceneTarget, SimulationInfo, SimulationTime
 
 
 class Scene(SessionContainer):
     """
-    Singleton wrapper for scene-level operations and view factory.
+    Singleton wrapper for scene-level operations.
 
     Uses a lazy singleton pattern - the first instantiation or call to get_current()
     creates the instance, and all subsequent calls return the same instance.
@@ -68,9 +64,8 @@ class Scene(SessionContainer):
         scene = Scene()  # or Scene.get_current()
         scene.clear()
         scene.toggle_ui(show_ui=False)
-        scene.set_speed(1.0)
         scene.play()
-        scene.step(dt=0.01)
+        scene.step(dt_us=1_000_000)
 
         # Add views
         geometry = scene.add_geometry(path="/World/box", ...)
@@ -278,34 +273,28 @@ class Scene(SessionContainer):
 
         self._session.query_sim_rpc(
             endpoint="set_simulation_controls",
-            payload=SetSimulationControls(
-                max_physics_dt_us=max_physics_dt_us,
-                render_interval_us=render_interval_us,
-            ),
+            payload={
+                "max_physics_dt_us": max_physics_dt_us,
+                "render_interval_us": render_interval_us,
+            },
         )
 
     def clear(self, timeout: float = 30.0) -> None:
         """
         Clear and completely reset the scene.
 
-        Stops any running Ark before clearing the scene. If a task is active,
-        restarts it to reset telemetry with the same configuration.
+        Stops any running Ark before clearing the scene.
 
         :param timeout: Timeout in seconds for stopping the Ark.
         """
 
-        from antioch.session.task import Task
-
         # Always try to stop the Ark via the agent (idempotent)
         self._agent.stop_ark(timeout=timeout)
         self._ark = None
 
-        # Clear the simulation scenne completely
+        # Clear the simulation scene completely
         self._session.query_sim_rpc(endpoint="clear")
 
-        # Clear any existing task
-        Task.get_current().clear()
-
     def restart(self) -> None:
         """
         Restart the simulation container.
@@ -317,8 +306,6 @@ class Scene(SessionContainer):
         Note: This function will not return as the process will be killed immediately.
         """
 
-        from antioch.session.task import Task
-
         # Always try to stop the Ark via the agent (idempotent)
         self._agent.stop_ark()
         self._ark = None
@@ -326,9 +313,6 @@ class Scene(SessionContainer):
         # Restart the RPC container
         self._session.query_sim_rpc(endpoint="restart")
 
-        # Clear any existing task
-        Task.get_current().clear()
-
     def toggle_ui(self, show_ui: bool) -> None:
         """
         Toggle the Isaac Sim UI visibility.
@@ -338,7 +322,7 @@ class Scene(SessionContainer):
 
         self._session.query_sim_rpc(
             endpoint="toggle_ui",
-            payload=ToggleUi(show_ui=show_ui),
+            payload={"show_ui": show_ui},
         )
 
     def set_camera_view(
@@ -357,11 +341,11 @@ class Scene(SessionContainer):
 
         self._session.query_sim_rpc(
             endpoint="set_camera_view",
-            payload=SetCameraView(
-                eye=Vector3.from_any(eye),
-                target=Vector3.from_any(target),
-                camera_prim_path=camera_prim_path,
-            ),
+            payload={
+                "eye": Vector3.from_any(eye),
+                "target": Vector3.from_any(target),
+                "camera_prim_path": camera_prim_path,
+            },
         )
 
     def set_active_viewport_camera(self, camera_prim_path: str) -> None:
@@ -373,7 +357,7 @@ class Scene(SessionContainer):
 
         self._session.query_sim_rpc(
             endpoint="set_active_viewport_camera",
-            payload=SetActiveViewportCamera(camera_prim_path=camera_prim_path),
+            payload={"camera_prim_path": camera_prim_path},
         )
 
     def get_prim_attribute(self, path: str, attribute_name: str) -> float | int | str | bool | list[float]:
@@ -389,9 +373,9 @@ class Scene(SessionContainer):
         """
 
         return self._session.query_sim_rpc(
-            endpoint="get_prim_attribute_value",
+            endpoint="scene/get_prim_attribute_value",
             response_type=PrimAttributeValue,
-            payload=GetPrimAttribute(path=path, attribute_name=attribute_name),
+            payload={"path": path, "attribute_name": attribute_name},
         ).value
 
     def set_prim_attribute(self, path: str, attribute_name: str, value: float | int | str | bool | list[float]) -> None:
@@ -408,8 +392,8 @@ class Scene(SessionContainer):
         """
 
         self._session.query_sim_rpc(
-            endpoint="set_prim_attribute_value",
-            payload=SetPrimAttribute(path=path, attribute_name=attribute_name, value=value),
+            endpoint="scene/set_prim_attribute_value",
+            payload={"path": path, "attribute_name": attribute_name, "value": value},
         )
 
     def query_scene(self, root_path: str = "/World", target: SceneTarget | None = None) -> SceneQueryResponse:
@@ -426,11 +410,20 @@ class Scene(SessionContainer):
         """
 
         return self._session.query_sim_rpc(
-            endpoint="query_scene_hierarchy",
+            endpoint="scene/query_hierarchy",
             response_type=SceneQueryResponse,
-            payload=QueryScene(root_path=root_path, target=target),
+            payload={"root_path": root_path, "target": target},
         )
 
+    def delete_prim(self, path: str) -> None:
+        """
+        Delete a prim from the scene.
+
+        :param path: USD path for the prim to delete.
+        """
+
+        self._session.query_sim_rpc(endpoint="scene/delete_prim", payload={"path": path})
+
     def add_asset(
         self,
         path: str,
@@ -485,18 +478,18 @@ class Scene(SessionContainer):
         if not asset_file_path:
             raise ValueError("Asset file path is required")
         self._session.query_sim_rpc(
-            endpoint="add_asset",
-            payload=AddAsset(
-                path=path,
-                asset_file_path=asset_file_path,
-                asset_prim_path=asset_prim_path,
-                remove_articulation=remove_articulation,
-                remove_rigid_body=remove_rigid_body,
-                remove_sensors=remove_sensors,
-                world_pose=Pose.from_any(world_pose) if world_pose is not None else None,
-                local_pose=Pose.from_any(local_pose) if local_pose is not None else None,
-                scale=Vector3.from_any(scale) if scale is not None else None,
-            ),
+            endpoint="scene/add_asset",
+            payload={
+                "path": path,
+                "asset_file_path": asset_file_path,
+                "asset_prim_path": asset_prim_path,
+                "remove_articulation": remove_articulation,
+                "remove_rigid_body": remove_rigid_body,
+                "remove_sensors": remove_sensors,
+                "world_pose": Pose.from_any(world_pose) if world_pose is not None else None,
+                "local_pose": Pose.from_any(local_pose) if local_pose is not None else None,
+                "scale": Vector3.from_any(scale) if scale is not None else None,
+            },
         )
         return path
 
@@ -527,7 +520,6 @@ class Scene(SessionContainer):
 
         :param path: USD path for the geometry.
         :param geometry_type: Type of geometry (sphere, cube, cylinder, cone, capsule, mesh).
-        :param name: Optional unique name for the view.
         :param radius: Radius for sphere/cylinder/cone/capsule.
         :param height: Height for cylinder/cone/capsule.
         :param size: Size for cube (uniform).
@@ -599,7 +591,6 @@ class Scene(SessionContainer):
         Add an articulation to the scene.
 
         :param path: USD path for the articulation.
-        :param name: Optional unique name for the view.
         :param joint_configs: Per-joint configurations (stiffness, damping, limits, etc).
         :param solver_position_iterations: Number of position iterations for the solver.
         :param solver_velocity_iterations: Number of velocity iterations for the solver.
@@ -657,7 +648,6 @@ class Scene(SessionContainer):
         :param path: USD path for the joint.
         :param parent_path: USD path to parent body.
         :param child_path: USD path to child body.
-        :param name: Optional unique name for the view.
         :param pose: Joint pose relative to parent (defaults to identity).
         :param joint_type: Type of joint motion (FIXED, REVOLUTE, PRISMATIC).
         :param axis: Axis of motion for non-fixed joints.
@@ -715,7 +705,6 @@ class Scene(SessionContainer):
         Add rigid body physics to the scene.
 
         :param path: USD path for the rigid body.
-        :param name: Optional unique name for the view.
         :param body_type: Body type (dynamic or kinematic).
         :param mass: Mass in kg.
         :param density: Density in kg/m³ (alternative to mass).
@@ -779,7 +768,6 @@ class Scene(SessionContainer):
         Add a light to the scene.
 
         :param path: USD path for the light.
-        :param name: Optional unique name for the view.
         :param light_type: Type of light (sphere, rect, disk, cylinder, distant, dome).
         :param intensity: Light intensity.
         :param exposure: Light exposure value.
@@ -834,7 +822,6 @@ class Scene(SessionContainer):
         Add an xform to the scene.
 
         :param path: USD path for the xform.
-        :param name: Optional unique name for the view.
         :param world_pose: Optional world pose as Pose (or dict with position/orientation lists).
         :param local_pose: Optional local pose as Pose (or dict with position/orientation lists).
         :param scale: Optional scale as Vector3 (or list/tuple of 3 floats).
@@ -945,8 +932,7 @@ class Scene(SessionContainer):
         """
         Add a ground plane to the scene.
 
-        :param path: USD path for the ground plane (default: "/World/ground").
-        :param name: Optional unique name for the view.
+        :param path: USD path for the ground plane.
         :param size: Size of the ground plane in meters.
         :param z_position: Z position of the ground plane.
         :param color: RGB color as Vector3 (or list/tuple of 3 floats) with values 0-1 (defaults to gray).
@@ -1004,7 +990,6 @@ class Scene(SessionContainer):
         Add a camera to the scene.
 
         :param path: USD path for the camera.
-        :param name: Optional unique name for the camera.
         :param config: Optional camera configuration (alternative to individual parameters).
         :param mode: Camera capture mode (RGB or depth).
         :param frequency: Camera update frequency in Hz.
@@ -1077,7 +1062,6 @@ class Scene(SessionContainer):
         Add an IMU to the scene.
 
         :param path: USD path for the IMU.
-        :param name: Optional unique name for the IMU.
         :param config: Optional IMU configuration (alternative to individual parameters).
         :param frequency: Sensor update frequency in Hz (optional, defaults to physics rate).
         :param linear_acceleration_filter_size: Filter window size for linear acceleration.
@@ -1133,7 +1117,6 @@ class Scene(SessionContainer):
         Add a radar to the scene.
 
         :param path: USD path for the radar.
-        :param name: Optional unique name for the radar.
         :param config: Optional radar configuration (alternative to individual parameters).
         :param frequency: Sensor update frequency in Hz.
         :param max_azimuth: Maximum azimuth angle in degrees (±FOV from center).
@@ -1176,6 +1159,9 @@ class Scene(SessionContainer):
         radius: float = 1.0,
         min_angle_deg: float = 0.0,
         max_angle_deg: float = 180.0,
+        guide: bool = False,
+        color: Vector3 | list[float] | tuple[float, float, float] | None = None,
+        width: float = 0.005,
     ) -> BasisCurve:
         """
         Add a basis curve semi-circle to the scene.
@@ -1185,6 +1171,9 @@ class Scene(SessionContainer):
         :param radius: Radius of the basis curve.
         :param min_angle_deg: Minimum angle of the basis curve in degrees.
         :param max_angle_deg: Maximum angle of the basis curve in degrees.
+        :param guide: If True, mark as guide purpose (invisible to cameras). If False, default purpose.
+        :param color: Optional RGB color [0-1].
+        :param width: Width of the curve.
         :return: The basis curve instance.
         """
 
@@ -1194,6 +1183,9 @@ class Scene(SessionContainer):
             radius=radius,
             min_angle_deg=min_angle_deg,
             max_angle_deg=max_angle_deg,
+            guide=guide,
+            color=Vector3.from_any(color) if color is not None else None,
+            width=width,
         )
 
     @overload
@@ -1203,6 +1195,9 @@ class Scene(SessionContainer):
         *,
         start: Vector3 | list[float] | tuple[float, float, float],
         end: Vector3 | list[float] | tuple[float, float, float],
+        guide: bool = False,
+        color: Vector3 | list[float] | tuple[float, float, float] | None = None,
+        width: float = 0.005,
     ) -> BasisCurve: ...
 
     @overload
@@ -1213,6 +1208,9 @@ class Scene(SessionContainer):
         start: Vector3 | list[float] | tuple[float, float, float],
         angle_deg: float,
         length: float,
+        guide: bool = False,
+        color: Vector3 | list[float] | tuple[float, float, float] | None = None,
+        width: float = 0.005,
     ) -> BasisCurve: ...
 
     def add_basis_curve_line(
@@ -1223,6 +1221,9 @@ class Scene(SessionContainer):
         end: Vector3 | list[float] | tuple[float, float, float] | None = None,
         angle_deg: float | None = None,
         length: float | None = None,
+        guide: bool = False,
+        color: Vector3 | list[float] | tuple[float, float, float] | None = None,
+        width: float = 0.005,
     ) -> BasisCurve:
         """
         Add a basis curve line to the scene.
@@ -1252,6 +1253,9 @@ class Scene(SessionContainer):
         :param end: End point of the line (Cartesian mode).
         :param angle_deg: Angle in degrees from +X axis in XY plane (polar mode).
         :param length: Length of the line (polar mode).
+        :param guide: If True, mark as guide purpose (invisible to cameras). If False, default purpose.
+        :param color: Optional RGB color [0-1].
+        :param width: Width of the curve.
         :return: The basis curve instance.
         :raises ValueError: If both modes are specified or neither mode is complete.
         """
@@ -1270,6 +1274,9 @@ class Scene(SessionContainer):
             end=Vector3.from_any(end) if end is not None else None,
             angle_deg=angle_deg,
             length=length,
+            guide=guide,
+            color=Vector3.from_any(color) if color is not None else None,
+            width=width,
         )
 
     def get_basis_curve(self, path: str) -> BasisCurve:
@@ -1282,41 +1289,6 @@ class Scene(SessionContainer):
 
         return BasisCurve(path)
 
-    def get_basis_curve_extents(self, path: str) -> tuple[Vector3, Vector3]:
-        """
-        Get the extents of the basis curve.
-
-        :param path: USD path for the basis curve.
-        :return: The extents of the basis curve.
-        """
-
-        return BasisCurve(path).get_extents()
-
-    def get_basis_curve_points(
-        self, path: str, samples_per_segment: int = 10, sort_by: Literal["X", "Y", "Z"] | None = None, ascending: bool = True
-    ) -> list[Vector3]:
-        """
-        Get the points of the basis curve.
-
-        :param path: USD path for the basis curve.
-        :param samples_per_segment: The number of samples per segment.
-        :param sort_by: The axis to sort the points by.
-        :param ascending: Whether to sort the points in ascending order.
-        :return: The points of the basis curve.
-        """
-
-        return BasisCurve(path).get_points(samples_per_segment=samples_per_segment, sort_by=sort_by, ascending=ascending)
-
-    def set_basis_curve_visibility(self, path: str, visible: bool) -> None:
-        """
-        Set the visibility of the basis curve.
-
-        :param path: USD path for the basis curve.
-        :param visible: True to make visible, False to hide.
-        """
-
-        BasisCurve(path).set_visibility(visible)
-
     def get_radar(self, path: str) -> Radar:
         """
         Get existing radar from the scene.
@@ -1500,12 +1472,7 @@ class Scene(SessionContainer):
 
         return get_mesh_approximation(path)
 
-    def set_pir_material(
-        self,
-        path: str,
-        emissivity: float = 0.9,
-        temperature_c: float | None = None,
-    ) -> None:
+    def set_pir_material(self, path: str, emissivity: float = 0.9, temperature_c: float | None = None) -> None:
         """
         Set PIR-specific thermal properties on a prim.
 
@@ -1523,22 +1490,33 @@ class Scene(SessionContainer):
 
         set_pir_material(path, emissivity, temperature_c)
 
-    def set_nonvisual_material(
-        self,
-        path: str,
-        base: str,
-        coating: str = "none",
-        attribute: str = "none",
-    ) -> int:
+    def set_nonvisual_material(self, path: str, base: str, coating: str = "none", attribute: str = "none") -> int:
         """
         Set non-visual material properties on all Material prims in a subtree.
 
         These properties define how objects appear to RTX sensors (LiDAR and Radar).
 
+        Valid base materials:
+            Metals: aluminum, steel, oxidized_steel, iron, oxidized_iron, silver, brass,
+                    bronze, oxidized_bronze_patina, tin
+            Polymers: plastic, fiberglass, carbon_fiber, vinyl, plexiglass, pvc, nylon, polyester
+            Glass: clear_glass, frosted_glass, one_way_mirror, mirror, ceramic_glass
+            Other: asphalt, concrete, leaf_grass, dead_leaf_grass, rubber, wood, bark,
+                   cardboard, paper, fabric, skin, fur_hair, leather, marble, brick,
+                   stone, gravel, dirt, mud, water, salt_water, snow, ice, calibration_lambertion
+            Default: none
+
+        Valid coatings: none, paint, clearcoat, paint_clearcoat
+
+        Valid attributes: none, emissive, retroreflective, single_sided, visually_transparent
+
         Example:
             # Make a person visible to radar/lidar with skin material
             scene.set_nonvisual_material("/World/person", base="skin")
 
+            # Make a car with aluminum body and paint coating
+            scene.set_nonvisual_material("/World/car", base="aluminum", coating="paint")
+
         :param path: USD path of the root prim to configure.
         :param base: Base material type.
         :param coating: Coating type.
@@ -1546,7 +1524,11 @@ class Scene(SessionContainer):
         :return: Number of Material prims modified.
         """
 
-        return set_nonvisual_material(path, base, coating, attribute)
+        return self._session.query_sim_rpc(
+            endpoint="material/set_nonvisual",
+            payload={"path": path, "base": base, "coating": coating, "attribute": attribute},
+            response_type=int,
+        )
 
     def _step_physics(self, dt_us: int) -> None:
         """
@@ -1558,5 +1540,5 @@ class Scene(SessionContainer):
         if dt_us > 0:
             self._session.query_sim_rpc(
                 endpoint="step",
-                payload=Step(dt_us=dt_us),
+                payload={"dt_us": dt_us},
             )

antioch/session/session.py

@@ -1,6 +1,6 @@
 import os
 import time
-from typing import overload
+from typing import Any, overload
 
 from antioch.session.error import (
     SessionSimRpcClientError,
@@ -50,7 +50,7 @@ class Session:
 
     Example:
         session = Session.get_current()
-        state = session.query_sim_rpc(endpoint="get_state", response_type=SimulationState)
+        result = session.query_sim_rpc("get_state")
     """
 
     _current: "Session | None" = None
@@ -96,11 +96,7 @@ class Session:
         """
 
         try:
-            self.query_sim_rpc(
-                endpoint="get_info",
-                response_type=SimulationInfo,
-                timeout=1.0,
-            )
+            self.query_sim_rpc("get_info", response_type=SimulationInfo, timeout=1.0)
             return True
         except Exception:
             return False
@@ -141,35 +137,37 @@ class Session:
     def query_sim_rpc(
         self,
         endpoint: str,
-        response_type: None = None,
-        payload: Message | None = None,
+        payload: dict[str, Any] | None = None,
+        *,
         timeout: float = 60.0,
-    ) -> None: ...
+    ) -> Any | None: ...
 
     @overload
-    def query_sim_rpc[T: Message](
+    def query_sim_rpc[T](
         self,
         endpoint: str,
+        payload: dict[str, Any] | None = None,
+        *,
         response_type: type[T],
-        payload: Message | None = None,
         timeout: float = 60.0,
     ) -> T: ...
 
-    def query_sim_rpc[T: Message](
+    def query_sim_rpc[T](
         self,
         endpoint: str,
+        payload: dict[str, Any] | None = None,
+        *,
         response_type: type[T] | None = None,
-        payload: Message | None = None,
         timeout: float = 60.0,
-    ) -> T | None:
+    ) -> T | Any | None:
         """
         Execute a sim RPC query.
 
         :param endpoint: The sim RPC endpoint.
-        :param response_type: Expected response payload type.
-        :param payload: Optional request payload.
+        :param payload: Optional request payload dict.
+        :param response_type: Expected response type (Message subclass or primitive like int, str, bool).
         :param timeout: Query timeout in seconds.
-        :return: The response payload or None if no payload.
+        :return: Response as typed object, arbitrary data, or None.
         :raises SessionSimRpcNotConnectedError: If the Sim RPC server is not reachable.
         :raises SessionSimRpcClientError: If the Sim RPC server returns a client error.
         :raises SessionSimRpcInternalError: If the Sim RPC server returns an internal error.
@@ -177,24 +175,33 @@ class Session:
 
         try:
             start_time = time.perf_counter() if self._debug else 0
-
-            # Normal RPC call
-            rpc_response = self._comms.query(
+            response = self._comms.query(
                 path=f"_sim/rpc/{endpoint}",
                 response_type=RpcResponse,
-                request=RpcCall(payload=payload.pack() if payload else None),
+                request=RpcCall(data=payload),
                 timeout=timeout or self._timeout,
             )
 
-            result = None
-            self._check_rpc_error(rpc_response)
-            if response_type is not None and rpc_response.payload is not None:
-                result = response_type.unpack(rpc_response.payload)
+            # Check for errors in RPC response
+            if response.error is not None:
+                if response.error.internal:
+                    raise SessionSimRpcInternalError(message=response.error.message, traceback=response.error.traceback)
+                else:
+                    raise SessionSimRpcClientError(response.error.message)
+
+            # Print elapsed time in debug mode
             if self._debug:
                 elapsed_ms = (time.perf_counter() - start_time) * 1000
                 print(f"[SIM-RPC] {endpoint}: {elapsed_ms:.1f}ms", flush=True)
 
-            return result
+            # Return response data or None if no data
+            if response.data is None:
+                return None
+            if response_type is not None:
+                if issubclass(response_type, Message):
+                    return response_type.model_validate(response.data)
+                return response.data
+            return response.data
 
         except TimeoutError as e:
             if not self.connected:
@@ -202,19 +209,3 @@ class Session:
             raise
         except KeyboardInterrupt as e:
             raise SessionSimRpcInterruptedError("Sim RPC interrupted") from e
-
-    @staticmethod
-    def _check_rpc_error(response: RpcResponse) -> None:
-        """
-        Check for errors in Sim RPC response and raise appropriate exceptions.
-
-        :param response: The Sim RPC response to check.
-        :raises SessionSimRpcInternalError: If response contains an internal error.
-        :raises SessionSimRpcClientError: If response contains a client error.
-        """
-
-        if response.error is not None:
-            if response.error.internal:
-                raise SessionSimRpcInternalError(message=response.error.message, traceback=response.error.traceback)
-            else:
-                raise SessionSimRpcClientError(response.error.message)