tinysim 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

tinysim/tinyspace.py

@@ -0,0 +1,68 @@
+from typing import Any
+
+import numpy as np
+
+# It is encouraged to implement your own Space classes or use existing ones from external libraries.
+
+
+class Space:
+    """A minimal implementation of the Space class for TinySim."""
+
+    def sample(self) -> Any:
+        """Randomly sample an element from this space."""
+        raise NotImplementedError
+
+    def contains(self, x: Any) -> bool:
+        """Return boolean specifying if x is a valid member of this space."""
+        raise NotImplementedError
+
+    def __contains__(self, x: Any) -> bool:
+        return self.contains(x)
+
+
+class Discrete(Space):
+    """A discrete space in TinySim."""
+
+    def __init__(self, n: int):
+        assert n >= 0, "n (number of elements) must be non-negative"
+        self.n = n
+
+    def sample(self) -> int:
+        return np.random.randint(0, self.n)
+
+    def contains(self, x: Any) -> bool:
+        return isinstance(x, int) and 0 <= x < self.n
+
+
+class Box(Space):
+    """A box space in TinySim."""
+
+    def __init__(self, low: float, high: float, shape: tuple, dtype=np.float32):
+        self.low = np.full(shape, low, dtype=dtype)
+        self.high = np.full(shape, high, dtype=dtype)
+        self.shape = shape
+        self.dtype = dtype
+
+    def sample(self) -> Any:
+        return np.random.uniform(self.low, self.high, self.shape)
+
+    def contains(self, x: Any) -> bool:
+        x = np.array(x)
+        return (
+            x.shape == self.shape and np.all(x >= self.low) and np.all(x <= self.high)
+        )
+
+
+class Dict(Space):
+    """A dictionary space in TinySim."""
+
+    def __init__(self, spaces: dict):
+        self.spaces = spaces
+
+    def sample(self) -> dict:
+        return {key: space.sample() for key, space in self.spaces.items()}
+
+    def contains(self, x: Any) -> bool:
+        if isinstance(x, dict) and x.keys() == self.spaces.keys():
+            return all(x[key] in self.spaces[key] for key in self.spaces.keys())
+        return False

tinysim/topdown_driving/__init__.py

@@ -1,9 +1,11 @@
 import json
 import math
-import numpy as np
 from pathlib import Path
-from .. import SimEnvironment
 
+import numpy as np
+
+from .. import SimEnvironment
+from ..tinyspace import Box
 
 try:
     with open(Path(__file__).parent / "track_0.json", "r") as f:
@@ -104,6 +106,9 @@ def collides(cx, cy):
 class TopDownDrivingEnv(SimEnvironment):
     def __init__(self, num_envs: int = 1):
         self.num_envs = num_envs
+
+        # throttle, steer
+        self.action_space = Box(low=-1.0, high=1.0, shape=(num_envs, 2))
         self.reset()
 
     def reset(self):
@@ -125,24 +130,18 @@ class TopDownDrivingEnv(SimEnvironment):
         }
 
     def step(self, action, dt=0.02):
-        throttle = action.get("throttle", 0.0)
-        steer = action.get("steer", 0.0)
-
-        if np.isscalar(throttle) and np.isscalar(steer):
-            throttle = np.full(self.num_envs, throttle, dtype=np.float32)
-            steer = np.full(self.num_envs, steer, dtype=np.float32)
-        elif isinstance(throttle, np.ndarray) and isinstance(steer, np.ndarray):
-            throttle = np.asarray(throttle, dtype=np.float32)
-            steer = np.asarray(steer, dtype=np.float32)
-            if throttle.shape[0] != self.num_envs or steer.shape[0] != self.num_envs:
-                raise ValueError(
-                    f"Expected actions of shape ({self.num_envs},), got {throttle.shape} and {steer.shape}"
-                )
-        else:
+        if not isinstance(action, np.ndarray):
             raise ValueError(
                 "Inputs throttle and steer must both be either scalars or numpy arrays."
             )
 
+        throttle = action[:, 0].astype(np.float32)
+        steer = action[:, 1].astype(np.float32)
+        if throttle.shape[0] != self.num_envs or steer.shape[0] != self.num_envs:
+            raise ValueError(
+                f"Expected actions of shape ({self.num_envs},), got {throttle.shape} and {steer.shape}"
+            )
+
         self.velocity += throttle * ACCELERATION * dt
         self.velocity = np.clip(self.velocity, 0.0, MAX_VEL)
         self.angle -= steer * TURN_SPEED * dt
@@ -171,8 +170,7 @@ class TopDownDrivingEnv(SimEnvironment):
         reward = self.prev_dist - dist
         reached = dist <= CHECKPOINT_RADIUS
 
-        bonus = 1.0
-        reward += np.where(reached, bonus, 0.0)
+        reward += np.where(reached, 1.0, 0.0)
         self.checkpoint_idx = np.where(
             reached, self.checkpoint_idx + 1, self.checkpoint_idx
         )

tinysim/topdown_driving/tk.py

@@ -1,25 +1,26 @@
-import asyncio
 import math
+
 from . import (
-    TopDownDrivingEnv,
     CAR_LENGTH,
     CAR_WIDTH,
-    LOCAL_WALLS,
     CHECKPOINTS,
+    LOCAL_WALLS,
     RAY_COUNT,
     RAY_SPREAD,
+    TopDownDrivingEnv,
 )
 
 try:
     import tkinter as tk
-    from .. import _tk_base
+
+    from .._tk_base import TkBaseFrontend
 except ImportError:
     raise ImportError("tkinter is required for MountainCarTkFrontend")
 
 
 CHECKPOINT_RADIUS = 0.85
 COLOR_MAP = ["red", "orange", "yellow", "green", "blue", "indigo", "violet"]
-
+CANVAS_W, CANVAS_H = 800, 600
 xs, ys = [], []
 
 for x, y, w, h, rot in LOCAL_WALLS:
@@ -30,8 +31,6 @@ for x, y, w, h, rot in LOCAL_WALLS:
 
 min_x, max_x = min(xs), max(xs)
 min_y, max_y = min(ys), max(ys)
-
-CANVAS_W, CANVAS_H = 800, 600
 scale = min((CANVAS_W - 2) / (max_x - min_x), (CANVAS_H - 2) / (max_y - min_y))
 offset_x = -min_x * scale
 offset_y = max_y * scale
@@ -53,33 +52,14 @@ def world_to_screen(x, y):
     return x * scale + offset_x, -y * scale + offset_y
 
 
-class TopDownDrivingTkFrontend(_tk_base.TkBaseFrontend):
+class TopDownDrivingTkFrontend(TkBaseFrontend):
 
-    def __init__(self, viewport_size=(800, 600), sim_env=None):
-        super().__init__()
-        if sim_env is None:
-            sim_env = TopDownDrivingEnv()
-        self.sim_env = sim_env
+    def __init__(self, viewport_size=(800, 600), sim_env=TopDownDrivingEnv()):
+        super().__init__(sim_env)
         self._viewport_size = viewport_size
         self.show_rays = False
-
         self.keys = set()
 
-    async def step(self, action, dt=0.02):
-        state = self.sim_env.step(action)
-
-        if self._root:
-            self._root.after(0, lambda s=state: self._draw_state(self.sim_env))
-
-        await asyncio.sleep(dt)
-        return state
-
-    async def reset(self):
-        state = self.sim_env.reset()
-        if self._canvas:
-            self._draw_state(self.sim_env)
-        return state
-
     def _create_window(self, root):
         w, h = self._viewport_size
         root.title("Top Down Driving")
@@ -94,7 +74,6 @@ class TopDownDrivingTkFrontend(_tk_base.TkBaseFrontend):
         r = CHECKPOINT_RADIUS * scale
         for i, (x, y) in enumerate(CHECKPOINTS):
             sx, sy = world_to_screen(x, y)
-
             canvas.create_oval(
                 sx - r,
                 sy - r,
@@ -115,26 +94,24 @@ class TopDownDrivingTkFrontend(_tk_base.TkBaseFrontend):
         self.bring_to_front(root)
         self._root = root
         self._canvas = canvas
-        self._draw_state(self.sim_env)
+        self._draw_state()
         self._pump()
         root.mainloop()
 
-    def _draw_state(self, sim_env):
+    def _draw_state(self, state=None):
+        sim_env = self.sim_env
         if not self._canvas:
             return
 
         c = self._canvas
         c.delete("car")
         c.delete("ray")
-
-        xs = sim_env.x
-        ys = sim_env.y
+        xs, ys = sim_env.x, sim_env.y
         angles = sim_env.angle
         n = len(xs)
 
         for i in range(n):
             cx, cy = world_to_screen(xs[i], ys[i])
-
             pts = rotated_rect(
                 cx,
                 cy,
@@ -160,7 +137,6 @@ class TopDownDrivingTkFrontend(_tk_base.TkBaseFrontend):
         for i in range(n):
             ox, oy = xs[i], ys[i]
             base = angles[i]
-
             sx1, sy1 = world_to_screen(ox, oy)
 
             for r_idx, dist in enumerate(sim_env.rays[i]):
@@ -168,7 +144,6 @@ class TopDownDrivingTkFrontend(_tk_base.TkBaseFrontend):
                 x2 = ox + math.cos(a) * dist
                 y2 = oy + math.sin(a) * dist
                 sx2, sy2 = world_to_screen(x2, y2)
-
                 c.create_line(
                     sx1,
                     sy1,