Colab Jupyter Notebook Demo

.github/workflows/ci-base-tests-linux.yml

@@ -39,7 +39,7 @@ jobs:
           . ${{env.venv_dir}}/bin/activate
           pip install --upgrade pip
           pip install --upgrade wheel
-          pip install -e .[camera-obs,opendrive,rllib,test,torch,train]
+          pip install -e .[camera-obs,opendrive,rllib,test,test-notebook,torch,train]
       - name: Run smoke tests
         run: |
           . ${{env.venv_dir}}/bin/activate

.github/workflows/ci-base-tests-mac.yml

@@ -47,7 +47,7 @@ jobs:
           pip install --upgrade pip
           pip install --upgrade wheel
           pip install -r utils/setup/mac_requirements.txt
-          pip install -e .[camera-obs,opendrive,rllib,test,torch,train]
+          pip install -e .[camera-obs,opendrive,rllib,test,test-notebook,torch,train]
       - name: Run smoke tests
         run: |
           . ${{env.venv_dir}}/bin/activate

cli/studio.py

@@ -52,88 +52,24 @@ def scenario_cli():
 )
 @click.argument("scenario", type=click.Path(exists=True), metavar="<scenario>")
 def build_scenario(clean: bool, allow_offset_map: bool, scenario: str):
-    _build_single_scenario(clean, allow_offset_map, scenario)
-
-
-def _build_single_scenario(clean: bool, allow_offset_map: bool, scenario: str):
     click.echo(f"build-scenario {scenario}")
-    if clean:
-        _clean(scenario)
-
-    scenario_root = Path(scenario)
-    scenario_root_str = str(scenario_root)
+    from smarts.sstudio.build_scenario import build_single_scenario
 
-    scenario_py = scenario_root / "scenario.py"
-    if scenario_py.exists():
-        _install_requirements(scenario_root)
-        subprocess.check_call([sys.executable, "scenario.py"], cwd=scenario_root)
-
-    from smarts.core.scenario import Scenario
-
-    traffic_histories = Scenario.discover_traffic_histories(scenario_root_str)
-    # don't shift maps for scenarios with traffic histories since history data must line up with map
-    shift_to_origin = not allow_offset_map and not bool(traffic_histories)
-
-    map_spec = Scenario.discover_map(scenario_root_str, shift_to_origin=shift_to_origin)
-    road_map, _ = map_spec.builder_fn(map_spec)
-    if not road_map:
-        click.echo(
-            "No reference to a RoadNetwork file was found in {}, or one could not be created. "
-            "Please make sure the path passed is a valid Scenario with RoadNetwork file required "
-            "(or a way to create one) for scenario building.".format(scenario_root_str)
-        )
-        return
-
-    road_map.to_glb(os.path.join(scenario_root, "map.glb"))
+    build_single_scenario(clean, allow_offset_map, scenario, click.echo)
 
 
 def _build_single_scenario_proc(
     clean: bool, allow_offset_map: bool, scenario: str, semaphore: synchronize.Semaphore
 ):
+    from smarts.sstudio.build_scenario import build_single_scenario
+
     semaphore.acquire()
     try:
-        _build_single_scenario(clean, allow_offset_map, scenario)
+        build_single_scenario(clean, allow_offset_map, scenario, click.echo)
     finally:
         semaphore.release()
 
 
-def _install_requirements(scenario_root):
-    import importlib.resources as pkg_resources
-
-    requirements_txt = scenario_root / "requirements.txt"
-    if requirements_txt.exists():
-        import zoo.policies
-
-        with pkg_resources.path(zoo.policies, "") as path:
-            # Serve policies through the static file server, then kill after
-            # we've installed scenario requirements
-            pip_index_proc = subprocess.Popen(
-                ["twistd", "-n", "web", "--path", path],
-                # Hide output to keep display simple
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.STDOUT,
-            )
-
-            pip_install_cmd = [
-                sys.executable,
-                "-m",
-                "pip",
-                "install",
-                "-r",
-                str(requirements_txt),
-            ]
-
-            click.echo(
-                f"Installing scenario dependencies via '{' '.join(pip_install_cmd)}'"
-            )
-
-            try:
-                subprocess.check_call(pip_install_cmd, stdout=subprocess.DEVNULL)
-            finally:
-                pip_index_proc.terminate()
-                pip_index_proc.wait()
-
-
 def _is_scenario_folder_to_build(path: str) -> bool:
     if os.path.exists(os.path.join(path, "waymo.yaml")):
         # for now, don't try to build Waymo scenarios...
@@ -195,32 +131,9 @@ def build_all_scenarios(clean: bool, allow_offset_maps: bool, scenarios: str):
 )
 @click.argument("scenario", type=click.Path(exists=True), metavar="<scenario>")
 def clean_scenario(scenario: str):
-    _clean(scenario)
+    from smarts.sstudio.build_scenario import clean_scenario
 
-
-def _clean(scenario: str):
-    to_be_removed = [
-        "map.glb",
-        "map_spec.pkl",
-        "bubbles.pkl",
-        "missions.pkl",
-        "flamegraph-perf.log",
-        "flamegraph.svg",
-        "flamegraph.html",
-        "*.rou.xml",
-        "*.rou.alt.xml",
-        "social_agents/*",
-        "traffic/*.rou.xml",
-        "traffic/*.smarts.xml",
-        "history_mission.pkl",
-        "*.shf",
-        "*-AUTOGEN.net.xml",
-    ]
-    p = Path(scenario)
-    for file_name in to_be_removed:
-        for f in p.glob(file_name):
-            # Remove file
-            f.unlink()
+    clean_scenario(scenario)
 
 
 @scenario_cli.command(name="replay", help="Play saved Envision data files in Envision.")

docs/setup.rst

@@ -32,6 +32,9 @@ To setup the simulator, which is called SMARTS, run the following commands,
     # OPTIONAL: install [camera-obs] version of python package with the panda3D dependencies if you want to render camera sensor observations in your simulations
     pip install -e .[camera-obs]
 
+    # OPTIONAL: install [opendrive] version of python package with the OpenDRIVE related dependencies if you are using the any OpenDRIVE related scenarios
+    pip install -e .[opendrive]
+
     # make sure you can run sanity-test (and verify they are passing)
     # if tests fail, check './sanity_test_result.xml' for test report.
     pip install -e .[test]

envision/client.py

@@ -175,6 +175,7 @@ def read_and_send(
         wait_between_retries: float = 0.5,
     ):
         """Send a pre-recorded envision simulation to the envision server."""
+
         client = Client(
             endpoint=endpoint,
             wait_between_retries=wait_between_retries,

envision/server.py

@@ -483,6 +483,7 @@ def get(self):
 
 def make_app(scenario_dirs: Sequence, max_capacity_mb: float, debug: bool):
     """Create the envision web server application through composition of services."""
+
     with pkg_resources.path(web_dist, ".") as dist_path:
         return tornado.web.Application(
             [

examples/__init__.py

@@ -1,10 +0,0 @@
-class RayException(Exception):
-    """An exception raised if ray package is required but not available."""
-
-    @classmethod
-    def required_to(cls, thing):
-        return cls(
-            f"""Ray Package is required to simulate {thing}.
-               You may not have installed the [rllib] or [train] dependencies required to run the ray dependent example.
-               Install them first using the command `pip install -e .[train, rllib]` at the source directory to install the package ray[rllib]==1.0.1.post1"""
-        )

examples/driving_in_traffic/requirements.txt

@@ -113,5 +113,5 @@ websocket-client==1.2.1
 Werkzeug==2.0.2
 wrapt==1.12.1
 yattag==1.14.0
-zipp==3.6.0
-zope.interface==5.4.0
+zipp==3.7.0
+zope.interface==5.4.0

examples/env/create_run_visualize.ipynb

@@ -0,0 +1,152 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wkR0YvENQni4"
+      },
+      "source": [
+        "**Setup dependencies**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "n1sQVa5mkMEA",
+        "outputId": "dbfa09f5-0fd9-4a51-f728-fc62230f1b84"
+      },
+      "outputs": [],
+      "source": [
+        "!git clone https://github.com/huawei-noah/SMARTS 2> /dev/null\n",
+        "!cd SMARTS && ls && git checkout develop && pip install .[camera-obs,remote_agent]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ubc6jEAqiCEq",
+        "outputId": "16e9facc-86bc-4f72-a4f2-2d8bb2961435"
+      },
+      "outputs": [],
+      "source": [
+        "import sys\n",
+        "sys.path.insert(0, \"/content/SMARTS/\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "s7UtcphinvNv"
+      },
+      "source": [
+        "**Import Base Modules**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "HsnDWYx_ngdc"
+      },
+      "outputs": [],
+      "source": [
+        "import gym\n",
+        "\n",
+        "from smarts.zoo import registry\n",
+        "from smarts.env.wrappers.episode_logger import EpisodeLogger"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "LFoG7Z-FobPP"
+      },
+      "source": [
+        "**Run an episode**"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 501
+        },
+        "id": "BBWj3wbAso3J",
+        "outputId": "63c1d665-b4a5-43b5-d926-b02b5bcce08f"
+      },
+      "outputs": [],
+      "source": [
+        "from smarts.core.utils.episodes import episode_range\n",
+        "from smarts.env.wrappers.record_video import RecordVideo\n",
+        "\n",
+        "import examples.env.figure_eight_env\n",
+        "env = gym.make(\"figure_eight-v0\")\n",
+        "env: gym.Env = RecordVideo(\n",
+        "    env, video_folder=\"videos\", video_length=40, step_trigger=lambda s: s % 100 == 0\n",
+        ")\n",
+        "env: gym.Env = EpisodeLogger(env)\n",
+        "\n",
+        "import zoo.policies.keep_lane_agent\n",
+        "agent = registry.make_agent(\"zoo.policies:keep-lane-agent-v0\")\n",
+        "\n",
+        "for episode in episode_range(max_steps=450):\n",
+        "    observation = env.reset()\n",
+        "    reward, done, info = None, False, None\n",
+        "    while episode.continues(observation, reward, done, info):\n",
+        "        action = agent.act(observation)\n",
+        "        observation, reward, done, info = env.step(action)\n",
+        "\n",
+        "env.close()\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from smarts.env.wrappers.utils.rendering import show_notebook_videos\n",
+        "show_notebook_videos()"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "name": "mock_demo.ipynb",
+      "provenance": []
+    },
+    "interpreter": {
+      "hash": "11a534571de20c647cd170207b7bb5d28d7f55463a5594e721a86394d5987d81"
+    },
+    "kernelspec": {
+      "display_name": "Python 3.8.10 ('.venv': venv)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.8.10"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

examples/env/figure_eight_env.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+
+import gym
+
+from smarts.zoo.agent_spec import AgentSpec
+from smarts.core.agent_interface import AgentInterface, AgentType
+from smarts.env.wrappers.single_agent import SingleAgent
+
+agent_spec = AgentSpec(
+    interface=AgentInterface.from_type(
+        AgentType.Laner,
+        max_episode_steps=150,
+        rgb=True,
+        ogm=True,
+        drivable_area_grid_map=True,
+    ),
+    agent_builder=None,
+)
+
+
+def entry_point(*args, **kwargs):
+    from smarts.env.hiway_env import HiWayEnv
+
+    scenario = str((Path(__file__).parent / "../../scenarios/figure_eight").resolve())
+    ## Note: can build the scenario here
+    from smarts.sstudio.build_scenario import build_single_scenario
+
+    build_single_scenario(clean=True, allow_offset_map=True, scenario=scenario)
+    hiwayenv = HiWayEnv(
+        agent_specs={"agent-007": agent_spec},
+        scenarios=[scenario],
+        headless=True,
+        sumo_headless=True,
+    )
+    hiwayenv.metadata["render.modes"] = set(hiwayenv.metadata["render.modes"]) | {
+        "rgb_array"
+    }
+    return SingleAgent(hiwayenv)
+
+
+gym.register("figure_eight-v0", entry_point=entry_point)