def main() -> None:
global inflation
parser = argparse.ArgumentParser(description=SCENE_SERVICE_NAME)
parser.add_argument("-s", "--swagger", action="store_true", default=False)
parser.add_argument(
"-d",
"--debug",
help="Set logging level to debug.",
action="store_const",
const=logging.DEBUG,
default=logging.DEBUG
if env.get_bool("ARCOR2_SCENE_DEBUG") else logging.INFO,
)
parser.add_argument(
"-i",
"--inflation",
help="How much to inflate collision objects (meters).",
nargs="?",
default=env.get_float("ARCOR2_SCENE_INFLATION", 0.01),
type=float,
)
args = parser.parse_args()
logger.setLevel(args.debug)
inflation = args.inflation
run_app(
app,
SCENE_SERVICE_NAME,
version(),
SCENE_PORT,
[
common.Pose,
object_type.Box,
object_type.Cylinder,
object_type.Sphere,
object_type.Mesh,
scene.MeshFocusAction,
scene.LineCheck,
scene.LineCheckResult,
],
args.swagger,
api_version="0.5.0",
)
import asyncio
import time
from collections import deque
from typing import Any, Awaitable, Callable, Coroutine, Optional, TypeVar
import websockets
from aiologger.levels import LogLevel
from dataclasses_jsonschema import ValidationError
from websockets.server import WebSocketServerProtocol as WsClient
from arcor2 import env, json
from arcor2.data.events import Event
from arcor2.data.rpc.common import RPC
from arcor2.exceptions import Arcor2Exception
MAX_RPC_DURATION = env.get_float("ARCOR2_MAX_RPC_DURATION", 0.1)
RPCT = TypeVar("RPCT", bound=RPC)
ReqT = TypeVar("ReqT", bound=RPC.Request)
RespT = TypeVar("RespT", bound=RPC.Response)
RPC_CB = Callable[[ReqT, WsClient], Coroutine[Any, Any, Optional[RespT]]]
RPC_DICT_TYPE = dict[str, tuple[type[RPC], RPC_CB]]
EventT = TypeVar("EventT", bound=Event)
EVENT_DICT_TYPE = dict[str, tuple[type[EventT], Callable[[EventT, WsClient],
Coroutine[Any, Any,
None]]]]
def custom_exception_handler(loop: asyncio.AbstractEventLoop,
app = create_app(__name__)
logger = get_logger(__name__)
logger.propagate = False
class CollisionObject(NamedTuple):
model: object_type.Models
pose: common.Pose
collision_objects: dict[str, CollisionObject] = {}
started: bool = False
inflation = 0.01
delay_mean = env.get_float("ARCOR2_MOCK_SCENE_DELAY_MEAN", 0)
delay_sigma = env.get_float("ARCOR2_MOCK_SCENE_DELAY_SIGMA", 0)
def delay() -> None:
"""This is to simulate the long-starting Scene service.
Could be useful to uncover specific kind of bugs.
:return:
"""
time.sleep(random.normalvariate(delay_mean, delay_sigma))
@app.route("/collisions/box", methods=["PUT"])
def put_box() -> RespT:
"""Add or update collision box.
get_robot_instance,
scene_started,
update_scene_object_pose,
)
from arcor2_arserver_data import rpc as srpc
from arcor2_arserver_data.events.common import ProcessState
from arcor2_arserver_data.events.robot import HandTeachingMode
RBT_CALIB = "RobotCalibration"
TaskDict = dict[str, asyncio.Task]
ROBOT_JOINTS_TASKS: TaskDict = {}
EEF_POSE_TASKS: TaskDict = {}
EVENT_PERIOD = env.get_float("ARCOR2_STREAMING_PERIOD", 0.1)
if EVENT_PERIOD <= 0:
EVENT_PERIOD = 0.1
async def robot_joints_event(robot_inst: Robot) -> None:
logger.info(f"Sending joints for {robot_inst.name} started.")
while scene_started() and glob.ROBOT_JOINTS_REGISTERED_UIS[robot_inst.id]:
start = time.monotonic()
try:
evt = RobotJoints(RobotJoints.Data(robot_inst.id, (await robot.get_robot_joints(robot_inst, None, True))))
except Arcor2Exception as e:
from arcor2.parameter_plugins.base import TypesDict
class ResourcesException(Arcor2Exception):
def __init__(self,
message: str,
exceptions: Optional[list[Arcor2Exception]] = None):
super().__init__(message)
self.exceptions = exceptions
CUSTOM_OBJECT_TYPES_MODULE = "object_types"
R = TypeVar("R", bound="Resources")
_shutting_down = Event()
_streaming_period = env.get_float("ARCOR2_STREAMING_PERIOD", 0.1)
def stream_pose(robot_inst: Robot) -> None:
arm_eef: dict[Optional[str], set[str]] = {}
try:
if isinstance(robot_inst, MultiArmRobot):
arms = robot_inst.get_arm_ids()
arm_eef.update(
{arm: robot_inst.get_end_effectors_ids(arm)
for arm in arms})
else:
arm_eef.update({None: robot_inst.get_end_effectors_ids()})
listing: dict[str, IdDesc]
ts: float
def time_to_update(self) -> bool:
return time.monotonic() - self.ts > _cache_timeout
"""
This module adds some caching capabilities to the aio version of project_service. It should be only used by ARServer.
Caching can be disabled by setting respective environment variable - this is useful for environments
where ARServer is not the only one who touches Project service.
"""
_cache_timeout = max(env.get_float("ARCOR2_ARSERVER_CACHE_TIMEOUT", 1.0), 0)
_cache_scenes = max(env.get_int("ARCOR2_ARSERVER_CACHE_SCENES", 32), 1)
_cache_projects = max(env.get_int("ARCOR2_ARSERVER_CACHE_PROJECTS", 64), 1)
_cache_object_types = max(
env.get_int("ARCOR2_ARSERVER_CACHE_OBJECT_TYPES", 64), 1)
# here we need to know all the items
_scenes_list = CachedListing({}, 0)
_projects_list = CachedListing({}, 0)
_object_type_list = CachedListing({}, 0)
_scenes_list_lock = asyncio.Lock()
_projects_list_lock = asyncio.Lock()
_object_type_lock = asyncio.Lock()
# here we can forget least used items
