tinysim 0.0.1__tar.gz

tinysim-0.0.1/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: tinysim
+Version: 0.0.1
+Summary: small modular simulation environments
+Author-email: Matthew Taylor <matthew.taylor.andre@gmail.com>
+Project-URL: Homepage, https://github.com/MatthewAndreTaylor/TinySim
+Keywords: jupyter,simulation
+Classifier: Framework :: Jupyter
+Classifier: Framework :: Jupyter :: JupyterLab
+Classifier: Framework :: Jupyter :: JupyterLab :: 4
+Classifier: Framework :: Jupyter :: JupyterLab :: Extensions
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: anywidget
+Requires-Dist: jupyter-ui-poll
+Provides-Extra: warp
+Requires-Dist: warp-lang==1.8.1; extra == "warp"
+
+
+# TinySim 
+
+[![PyPI](https://img.shields.io/pypi/v/coderbot-sim.svg)](https://pypi.org/project/coderbot-sim)
+[![Jupyterlite](https://jupyterlite.rtfd.io/en/latest/_static/badge.svg)](https://matthewandretaylor.github.io/CoderBots/lab?path=example.ipynb)
+
+The goal of this project is to create more minimal simulation environments for robotics and machine learning.
+
+Existing solutions like [ROS 2](https://github.com/ros2) and [Gymnasium](https://gymnasium.farama.org/) come with many heavy dependencies.
+
+Additionally they are usually difficult to get setup and may require domain specific knowledge to use.
+Simulation environments should be able to run in any notebook environment and require fewer dependencies.
+
+
+## Get Started 🚀
+
+To use the baseline Python only simulation environments.
+
+```bash
+pip install tinysim
+```
+
+To use the [warp](https://github.com/NVIDIA/warp) simulation environments.
+
+```bash
+pip install tinysim[warp]
+```
+
+
+

tinysim-0.0.1/README.md

@@ -0,0 +1,30 @@
+
+# TinySim 
+
+[![PyPI](https://img.shields.io/pypi/v/coderbot-sim.svg)](https://pypi.org/project/coderbot-sim)
+[![Jupyterlite](https://jupyterlite.rtfd.io/en/latest/_static/badge.svg)](https://matthewandretaylor.github.io/CoderBots/lab?path=example.ipynb)
+
+The goal of this project is to create more minimal simulation environments for robotics and machine learning.
+
+Existing solutions like [ROS 2](https://github.com/ros2) and [Gymnasium](https://gymnasium.farama.org/) come with many heavy dependencies.
+
+Additionally they are usually difficult to get setup and may require domain specific knowledge to use.
+Simulation environments should be able to run in any notebook environment and require fewer dependencies.
+
+
+## Get Started 🚀
+
+To use the baseline Python only simulation environments.
+
+```bash
+pip install tinysim
+```
+
+To use the [warp](https://github.com/NVIDIA/warp) simulation environments.
+
+```bash
+pip install tinysim[warp]
+```
+
+
+

tinysim-0.0.1/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "tinysim"
+version = "0.0.1"
+description = "small modular simulation environments"
+authors = [
+    {name = "Matthew Taylor", email = "matthew.taylor.andre@gmail.com"},
+]
+requires-python = ">=3.9"
+classifiers = [
+    "Framework :: Jupyter",
+    "Framework :: Jupyter :: JupyterLab",
+    "Framework :: Jupyter :: JupyterLab :: 4",
+    "Framework :: Jupyter :: JupyterLab :: Extensions",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+urls = {Homepage = "https://github.com/MatthewAndreTaylor/TinySim"}
+keywords = ["jupyter", "simulation"]
+
+dependencies = [
+    "numpy",
+    "anywidget",
+    "jupyter-ui-poll"
+]
+
+[project.optional-dependencies]
+warp = ["warp-lang==1.8.1"]
+
+[project.readme]
+file = "README.md"
+content-type = "text/markdown"
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["tinysim", "tinysim_warp"]
+include-package-data = true
+
+[tool.setuptools.package-data]
+tinysim = ["**/*"]
+tinysim_warp = ["**/*"]
+
+

tinysim-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tinysim-0.0.1/tinysim/__init__.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+
+class SimEnvironment(ABC):
+    @abstractmethod
+    def step(self, action) -> dict:
+        pass
+
+    @abstractmethod
+    def reset(self) -> dict:
+        pass

tinysim-0.0.1/tinysim/_tk_base.py

@@ -0,0 +1,54 @@
+import tkinter as tk
+import threading
+from abc import ABC, abstractmethod
+
+
+class TkBaseFrontend(ABC):
+
+    def __init__(self):
+        self._root = None
+        self._canvas = None
+        self._thread = None
+
+    def render(self):
+        if self._thread is not None:
+            return
+        self._thread = threading.Thread(target=self._window_hook, daemon=True)
+        self._thread.start()
+
+    def _window_hook(self):
+        root = tk.Tk()
+        root.protocol("WM_DELETE_WINDOW", self._on_close)
+        self._create_window(root)
+
+    @abstractmethod
+    def _create_window(self, root):
+        pass
+
+    def bring_to_front(self, root):
+        root.lift()
+        root.attributes("-topmost", True)
+        root.after_idle(root.attributes, "-topmost", False)
+        root.focus_force()
+
+    def _on_close(self):
+        if self._root:
+            try:
+                self._root.destroy()
+            except tk.TclError:
+                pass
+        self._root = None
+        self._canvas = None
+
+    def _pump(self):
+        if not self._root:
+            return
+
+        try:
+            self._root.update_idletasks()
+            self._root.update()
+        except tk.TclError:
+            return
+
+        if self._root:
+            self._root.after(20, self._pump)

tinysim-0.0.1/tinysim/flappy/__init__.py

@@ -0,0 +1,103 @@
+import numpy as np
+from .. import SimEnvironment
+
+WIDTH, HEIGHT = 800, 600
+GRAVITY = 900.0
+FLAP_STRENGTH = -300.0
+PIPE_SPEED = -200.0
+PIPE_WIDTH = 80
+PIPE_GAP = 200
+PIPE_INTERVAL = 1.6
+
+BIRD_X = 200
+BIRD_SIZE = 35
+
+
+class FlappyEnv(SimEnvironment):
+    def __init__(self, num_envs: int = 1):
+        self.num_envs = num_envs
+        self.reset()
+
+    def reset(self):
+        # birds (vectorized)
+        self.bird_y = np.full(self.num_envs, HEIGHT / 2, dtype=np.float32)
+        self.bird_vel = np.zeros(self.num_envs, dtype=np.float32)
+        self.done = np.zeros(self.num_envs, dtype=bool)
+
+        # shared pipes
+        self.pipes_x = np.empty(0, dtype=np.float32)
+        self.pipes_y = np.empty(0, dtype=np.float32)
+        self.time_since_pipe = PIPE_INTERVAL
+        return self.step(np.zeros(self.num_envs, dtype=np.int32), dt=0.0)
+
+    def _step_physics(self, action, dt):
+        flap_mask = (action == 1) & (~self.done)
+        self.bird_vel[flap_mask] = FLAP_STRENGTH
+        self.bird_vel += GRAVITY * dt
+        self.bird_y += self.bird_vel * dt
+
+    def _spawn_pipe(self):
+        pipe_y = np.random.randint(120, HEIGHT - 120 - PIPE_GAP)
+        self.pipes_x = np.append(self.pipes_x, WIDTH)
+        self.pipes_y = np.append(self.pipes_y, pipe_y)
+
+    def _update_pipes(self, dt):
+        self.time_since_pipe += dt
+        if self.time_since_pipe > PIPE_INTERVAL:
+            self.time_since_pipe = 0.0
+            self._spawn_pipe()
+
+        self.pipes_x += PIPE_SPEED * dt
+
+        # keep pipes on screen
+        keep = self.pipes_x > -PIPE_WIDTH
+        self.pipes_x = self.pipes_x[keep]
+        self.pipes_y = self.pipes_y[keep]
+
+    def _check_collisions(self):  # world bounds
+        hit_bounds = (self.bird_y < 0) | (self.bird_y + BIRD_SIZE > HEIGHT)
+        bx = BIRD_X
+        by = self.bird_y[:, None]
+        px = self.pipes_x[None, :]
+        upper_y = np.zeros_like(self.pipes_y)[None, :]
+        upper_h = self.pipes_y[None, :]
+        lower_y = (self.pipes_y + PIPE_GAP)[None, :]
+        lower_h = (HEIGHT - (self.pipes_y + PIPE_GAP))[None, :]
+        x_overlap = (bx < px + PIPE_WIDTH) & (bx + BIRD_SIZE > px)
+        upper_hit = x_overlap & (by < upper_y + upper_h) & (by + BIRD_SIZE > upper_y)
+        lower_hit = x_overlap & (by < lower_y + lower_h) & (by + BIRD_SIZE > lower_y)
+        hit_pipe = (upper_hit | lower_hit).any(axis=1)
+        self.done |= hit_bounds | hit_pipe
+
+    def step(self, action, dt=0.02):
+        if np.isscalar(action):
+            action = np.full(self.num_envs, action, dtype=np.float32)
+        else:
+            action = np.asarray(action, dtype=np.float32)
+            if action.shape[0] != self.num_envs:
+                raise ValueError(
+                    f"Expected actions of shape ({self.num_envs},), got {action.shape}"
+                )
+
+        # mask done environments to have no action
+        action = action * (~self.done)
+        self._step_physics(action, dt)
+        self._update_pipes(dt)
+        self._check_collisions()
+
+        bird_y = self.bird_y.tolist()
+        bird_vel = self.bird_vel.tolist()
+        done = self.done.tolist()
+
+        if self.num_envs == 1:
+            bird_y = self.bird_y[0]
+            bird_vel = self.bird_vel[0]
+            done = bool(self.done[0])
+
+        return {
+            "bird_y": bird_y,
+            "bird_vel": bird_vel,
+            "pipes_x": self.pipes_x.tolist(),
+            "pipes_y": self.pipes_y.tolist(),
+            "done": done,
+        }

tinysim-0.0.1/tinysim/flappy/sim.js

@@ -0,0 +1,118 @@
+let simState = {};
+
+export default {
+  initialize({ model }) {
+    model.on("change:sim_state", () => {
+      simState = model.get("sim_state") || {};
+    });
+  },
+
+  async render({ model, el }) {
+    const [width, height] = model.get("_viewport_size") || [800, 600];
+
+    const container = document.createElement("div");
+    container.style.position = "relative";
+    container.style.width = width + "px";
+    container.style.height = height + "px";
+    el.appendChild(container);
+
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    container.appendChild(canvas);
+    const ctx = canvas.getContext("2d");
+
+    const WORLD_WIDTH = 800;
+    const WORLD_HEIGHT = 600;
+    const BIRD_X = 200;
+    const BIRD_SIZE = 35;
+    const PIPE_WIDTH = 80;
+    const PIPE_GAP = 200;
+    const GROUND_HEIGHT = 80;
+
+    // Scale world to canvas (in case viewport differs from 800×600)
+    const scaleX = width / WORLD_WIDTH;
+    const scaleY = height / WORLD_HEIGHT;
+
+    function draw() {
+      const state = simState || {};
+      const birdY = state.bird_y ?? WORLD_HEIGHT / 2;
+      const pipes_x = state.pipes_x || [];
+      const pipes_y = state.pipes_y || [];
+      const done = state.done || false;
+
+      ctx.clearRect(0, 0, width, height);
+
+      // Background sky
+      ctx.fillStyle = "#70C5CE";
+      ctx.fillRect(0, 0, width, height);
+
+      // Ground
+      const groundH = GROUND_HEIGHT * scaleY;
+      ctx.fillStyle = "#DED895";
+      ctx.fillRect(0, height - groundH, width, groundH);
+
+      // Bird
+      const birdScreenX = BIRD_X * scaleX;
+      const birdScreenY = birdY * scaleY;
+      const birdSizeX = BIRD_SIZE * scaleX;
+      const birdSizeY = BIRD_SIZE * scaleY;
+
+      ctx.fillStyle = "#FFD700";
+      ctx.strokeStyle = "#000000";
+      ctx.lineWidth = 1;
+
+      if (!done) {
+        ctx.beginPath();
+        ctx.ellipse(
+          birdScreenX + birdSizeX / 2,
+          birdScreenY + birdSizeY / 2,
+          birdSizeX / 2,
+          birdSizeY / 2,
+          0,
+          0,
+          Math.PI * 2
+        );
+        ctx.fill();
+        ctx.stroke();
+      }
+
+      // Pipes
+      ctx.fillStyle = "#228B22";
+      ctx.strokeStyle = "#4a8d34";
+      ctx.lineWidth = 2 * ((scaleX + scaleY) / 2);
+
+      for (let i = 0; i < pipes_x.length; i++) {
+        const pipeX = pipes_x[i];
+        const pipeY = pipes_y[i];
+
+        const pw = PIPE_WIDTH * scaleX;
+        const ux = pipeX * scaleX;
+        const uy = 0; // Upper pipe starts at top of screen
+        const uh = pipeY * scaleY; // Upper pipe height extends down to pipeY
+        const lx = pipeX * scaleX;
+        const ly = (pipeY + PIPE_GAP) * scaleY; // Lower pipe starts after gap
+        const lh = (WORLD_HEIGHT - (pipeY + PIPE_GAP)) * scaleY; // Lower pipe extends to bottom
+
+        // Upper pipe
+        ctx.beginPath();
+        ctx.rect(ux, uy, pw, uh);
+        ctx.fill();
+        ctx.stroke();
+
+        // Lower pipe
+        ctx.beginPath();
+        ctx.rect(lx, ly, pw, lh);
+        ctx.fill();
+        ctx.stroke();
+      }
+
+      requestAnimationFrame(draw);
+    }
+
+    draw();
+
+    model.set("_view_ready", true);
+    model.save_changes();
+  }
+};

tinysim-0.0.1/tinysim/flappy/tk.py

@@ -0,0 +1,94 @@
+import asyncio
+
+try:
+    import tkinter as tk
+    from .. import _tk_base
+except ImportError:
+    raise ImportError("tkinter is required for FlappyTkFrontend")
+
+from . import (
+    FlappyEnv,
+    WIDTH,
+    HEIGHT,
+    PIPE_WIDTH,
+    BIRD_SIZE,
+    BIRD_X,
+    PIPE_GAP,
+)
+
+
+class FlappyTkFrontend(_tk_base.TkBaseFrontend):
+
+    def __init__(self, viewport_size=(800, 600), sim_env=None):
+        super().__init__()
+        if sim_env is None:
+            sim_env = FlappyEnv()
+
+        self.sim_env = sim_env
+        self._viewport_size = viewport_size
+
+    async def step(self, action, dt=0.02):
+        state = self.sim_env.step(action, dt=dt)
+        if self._root:
+            self._root.after(0, lambda: self._draw_state(state))
+
+        await asyncio.sleep(dt)
+        return state
+
+    async def reset(self):
+        state = self.sim_env.reset()
+        if self._root:
+            self._draw_state(state)
+        return state
+
+    def _create_window(self, root):
+        w, h = self._viewport_size
+        root.title("Flappy Bird")
+        canvas = tk.Canvas(root, width=w, height=h, bg="#1E1E1E")
+        canvas.pack(fill="both", expand=True)
+        self._root = root
+        self._canvas = canvas
+        self.bring_to_front(root)
+        self._draw_state(self.sim_env.reset())
+        self._pump()
+        root.mainloop()
+
+    def _draw_state(self, state):
+        if not self._canvas:
+            return
+
+        canvas = self._canvas
+        canvas.delete("all")
+        canvas.create_rectangle(0, 0, WIDTH, HEIGHT, fill="#70C5CE", outline="")
+        canvas.create_rectangle(
+            0, HEIGHT - 80, WIDTH, HEIGHT, fill="#DED895", outline=""
+        )
+
+        # bird
+        by = state["bird_y"]
+
+        if not state.get("done", False):
+            canvas.create_oval(
+                BIRD_X,
+                by,
+                BIRD_X + BIRD_SIZE,
+                by + BIRD_SIZE,
+                fill="#FFD700",
+                outline="#000",
+            )
+
+        # pipes
+        for x, y in zip(state["pipes_x"], state["pipes_y"]):
+            # Upper pipe
+            canvas.create_rectangle(
+                x, 0, x + PIPE_WIDTH, y, fill="#228B22", outline="#4a8d34"
+            )
+            # Lower pipe
+            canvas.create_rectangle(
+                x,
+                y + PIPE_GAP,
+                x + PIPE_WIDTH,
+                HEIGHT,
+                fill="#228B22",
+                outline="#4a8d34",
+            )

tinysim-0.0.1/tinysim/flappy/widget.py

@@ -0,0 +1,53 @@
+import pathlib
+import anywidget
+import traitlets
+import asyncio
+from IPython.display import display
+from jupyter_ui_poll import ui_events
+
+from . import FlappyEnv
+
+
+class FlappySim(anywidget.AnyWidget):
+    _esm = pathlib.Path(__file__).parent / "sim.js"
+
+    sim_state = traitlets.Dict(default_value={}).tag(sync=True)
+    _viewport_size = traitlets.Tuple(
+        traitlets.Int(), traitlets.Int(), default_value=(800, 600)
+    ).tag(sync=True)
+    _manual_control = traitlets.Bool(default_value=False).tag(sync=True)
+    _view_ready = traitlets.Bool(default_value=False).tag(sync=True)
+
+    def __init__(self, viewport_size=(800, 600), manual_control=False, sim_env=None):
+        super().__init__()
+        self._viewport_size = viewport_size
+        self._manual_control = manual_control
+        if sim_env is None:
+            sim_env = FlappyEnv()
+        if sim_env.num_envs != 1:
+            raise ValueError("FlappySim currently only supports single environment.")
+
+        self.sim_env = sim_env
+        self.sim_state = self.sim_env.reset()
+
+    def render(self):
+        display(self)
+
+        try:
+            with ui_events() as ui_poll:
+                while not self._view_ready:
+                    ui_poll(100)
+        except Exception:
+            pass
+
+    async def step(self, action, dt=0.02):
+        state = self.sim_env.step(action, dt=dt)
+        self.sim_state = state
+        await asyncio.sleep(dt)
+        return state
+
+    async def reset(self):
+        state = self.sim_env.reset()
+        self.sim_state = state
+        await asyncio.sleep(0)
+        return state