RoutingGraphEnv 0.0.1__py3-none-any.whl

RoutingGraphEnv/__init__.py

@@ -0,0 +1,6 @@
+from gymnasium.envs.registration import register
+
+register(
+    id="RoutingGraphEnv/RoutingGraph-v0",
+    entry_point="RoutingGraphEnv.envs:RoutingGraphEnv",
+)

RoutingGraphEnv/envs/__init__.py

@@ -0,0 +1,4 @@
+from RoutingGraphEnv.envs.openstreetmap_services import OpenStreetMapService
+from RoutingGraphEnv.envs.routing_graph import RoutingGraphEnv
+
+__all__ = ["OpenStreetMapService", "RoutingGraphEnv"]

RoutingGraphEnv/envs/openstreetmap_services.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import random
+
+import networkx as nx
+import numpy as np
+import osmnx as ox
+from networkx import MultiDiGraph
+
+
+class OpenStreetMapService:
+    """Load road networks and select reproducible routing nodes."""
+
+    @staticmethod
+    def load_drive_graph(
+        place_name: str,
+        simplify: bool = True,
+    ) -> MultiDiGraph:
+        graph = ox.graph_from_place(
+            place_name,
+            network_type="drive",
+            simplify=simplify,
+        )
+
+        return ox.truncate.largest_component(
+            graph,
+            strongly=True,
+        )
+
+    @staticmethod
+    def generate_random_road_nodes(
+        graph: MultiDiGraph,
+        count: int,
+        seed: int | None = None,
+    ) -> list[dict]:
+        if count < 2:
+            raise ValueError("count must be at least 2")
+
+        node_ids = list(graph.nodes)
+        if count > len(node_ids):
+            raise ValueError(
+                f"Requested {count} nodes but graph only has {len(node_ids)} nodes."
+            )
+
+        selected = random.Random(seed).sample(node_ids, count)
+        return [
+            {
+                "id": index,
+                "osm_node_id": node_id,
+                "latitude": graph.nodes[node_id]["y"],
+                "longitude": graph.nodes[node_id]["x"],
+            }
+            for index, node_id in enumerate(selected)
+        ]
+
+    @classmethod
+    def generate_random_points_on_roads(
+        cls,
+        place_name: str,
+        count: int,
+        seed: int | None = None,
+    ) -> tuple[MultiDiGraph, list[dict]]:
+        graph = cls.load_drive_graph(place_name)
+        return graph, cls.generate_random_road_nodes(graph, count, seed)
+
+    @staticmethod
+    def distance_matrix(
+        graph: MultiDiGraph,
+        nodes: list[dict],
+    ) -> np.ndarray:
+        """Compute selected-node distances with one Dijkstra run per source."""
+        node_ids = [node["osm_node_id"] for node in nodes]
+        matrix = np.full((len(node_ids), len(node_ids)), np.inf, dtype=np.float32)
+        np.fill_diagonal(matrix, 0.0)
+
+        for source_index, source_id in enumerate(node_ids):
+            lengths = nx.single_source_dijkstra_path_length(
+                graph,
+                source_id,
+                weight="length",
+            )
+            for target_index, target_id in enumerate(node_ids):
+                if source_index != target_index:
+                    matrix[source_index, target_index] = lengths.get(
+                        target_id, float("inf")
+                    )
+
+        return matrix

RoutingGraphEnv/envs/routing_graph.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+from typing import Any
+
+import gymnasium as gym
+import numpy as np
+from gymnasium import spaces
+from networkx import MultiDiGraph
+
+from RoutingGraphEnv.envs.openstreetmap_services import OpenStreetMapService
+
+
+class RoutingGraphEnv(gym.Env):
+    """Gymnasium environment for finding a short round trip through road nodes."""
+
+    metadata = {"render_modes": ["human", "rgb_array"], "render_fps": 4}
+
+    def __init__(
+        self,
+        render_mode: str | None = None,
+        num_nodes: int = 5,
+        place_name: str = "Tan Binh District, Ho Chi Minh City, Vietnam",
+        graph: MultiDiGraph | None = None,
+        nodes: list[dict[str, Any]] | None = None,
+    ) -> None:
+        if num_nodes < 2:
+            raise ValueError("num_nodes must be at least 2")
+        if render_mode not in (None, *self.metadata["render_modes"]):
+            raise ValueError(f"Unsupported render mode: {render_mode}")
+        if (graph is None) != (nodes is None):
+            raise ValueError("graph and nodes must be provided together")
+
+        self.render_mode = render_mode
+        self.num_nodes = num_nodes
+        self.place_name = place_name
+        self.window_size = 720
+        self.window = None
+        self.clock = None
+        self._render_font = None
+        self._render_small_font = None
+
+        if graph is None:
+            graph, nodes = OpenStreetMapService.generate_random_points_on_roads(
+                place_name=place_name,
+                count=num_nodes,
+                seed=42,
+            )
+        elif len(nodes) != num_nodes:
+            raise ValueError("len(nodes) must equal num_nodes")
+
+        self.graph = graph
+        self.nodes = nodes
+        self.distance_matrix = OpenStreetMapService.distance_matrix(graph, nodes)
+        if not np.isfinite(self.distance_matrix).all():
+            raise ValueError("Selected road nodes are not mutually reachable")
+
+        self.observation_space = spaces.Dict(
+            {
+                "visit_order": spaces.Box(
+                    low=-1,
+                    high=num_nodes - 1,
+                    shape=(num_nodes,),
+                    dtype=np.int32,
+                ),
+                "visited": spaces.MultiBinary(num_nodes),
+                "current_node": spaces.Discrete(num_nodes),
+            }
+        )
+        self.action_space = spaces.Discrete(num_nodes)
+
+        self._visit_order = np.full(num_nodes, -1, dtype=np.int32)
+        self._visited = np.zeros(num_nodes, dtype=np.int8)
+        self._current_node = 0
+        self._step_count = 0
+        self._total_distance = 0.0
+        self._render_positions: np.ndarray | None = None
+
+    def _get_obs(self) -> dict[str, np.ndarray | int]:
+        return {
+            "visit_order": self._visit_order.copy(),
+            "visited": self._visited.copy(),
+            "current_node": self._current_node,
+        }
+
+    def _get_info(self) -> dict[str, float]:
+        return {"total_distance": self._total_distance}
+
+    def action_masks(self) -> np.ndarray:
+        return np.logical_not(self._visited).astype(dtype=np.int8)
+
+    def reset(
+        self,
+        seed: int | None = None,
+        options: dict[str, Any] | None = None,
+    ) -> tuple[dict[str, np.ndarray | int], dict[str, float]]:
+        super().reset(seed=seed)
+        start_node = 0 if options is None else int(options.get("start_node", 0))
+        if not self.action_space.contains(start_node):
+            raise ValueError("start_node is outside the action space")
+
+        self._visit_order.fill(-1)
+        self._visited.fill(0)
+        self._visit_order[0] = start_node
+        self._visited[start_node] = 1
+        self._current_node = start_node
+        self._step_count = 1
+        self._total_distance = 0.0
+
+        if self.render_mode == "human":
+            self._render_frame()
+        return self._get_obs(), self._get_info()
+
+    def step(
+        self,
+        action: int,
+    ) -> tuple[dict[str, np.ndarray | int], float, bool, bool, dict[str, float]]:
+        if not self.action_space.contains(action):
+            raise ValueError(f"Invalid action: {action}")
+        action = int(action)
+        if self._visited[action]:
+            return self._get_obs(), -1.0, False, False, {
+                **self._get_info(),
+                "invalid_action": True,
+            }
+
+        distance = float(self.distance_matrix[self._current_node, action])
+        self._total_distance += distance
+        self._current_node = action
+        self._visit_order[self._step_count] = action
+        self._visited[action] = 1
+        self._step_count += 1
+
+        terminated = self._step_count == self.num_nodes
+        if terminated:
+            return_distance = float(self.distance_matrix[action, self._visit_order[0]])
+            distance += return_distance
+            self._total_distance += return_distance
+
+        if self.render_mode == "human":
+            self._render_frame()
+        return self._get_obs(), -distance, terminated, False, self._get_info()
+
+    def render(self) -> np.ndarray | None:
+        if self.render_mode == "rgb_array":
+            return self._render_frame()
+        return None
+
+    def _render_frame(self) -> np.ndarray | None:
+        import pygame
+        import pygame._freetype as freetype
+
+        if self.window is None and self.render_mode == "human":
+            pygame.init()
+            pygame.display.init()
+            self.window = pygame.display.set_mode((self.window_size, self.window_size))
+            pygame.display.set_caption("Routing Graph Environment")
+            self.clock = pygame.time.Clock()
+        if not freetype.get_init():
+            freetype.init()
+        if self._render_font is None:
+            self._render_font = freetype.Font(None, 22)
+            self._render_small_font = freetype.Font(None, 16)
+
+        canvas = pygame.Surface((self.window_size, self.window_size))
+        canvas.fill((238, 242, 247))
+
+        map_rect = pygame.Rect(28, 92, self.window_size - 56, self.window_size - 156)
+        pygame.draw.rect(canvas, (220, 231, 220), map_rect, border_radius=18)
+        pygame.draw.rect(canvas, (133, 158, 136), map_rect, width=2, border_radius=18)
+
+        title = self._render_font.render(self.place_name, (30, 41, 59))[0]
+        canvas.blit(title, (28, 22))
+        status = self._render_small_font.render(
+            f"Visited: {self._step_count}/{self.num_nodes}    "
+            f"Distance: {self._total_distance / 1000:.2f} km",
+            (71, 85, 105),
+        )[0]
+        canvas.blit(status, (28, 56))
+
+        if self._render_positions is None:
+            coordinates = np.asarray(
+                [[node["longitude"], node["latitude"]] for node in self.nodes],
+                dtype=np.float64,
+            )
+            minimum = coordinates.min(axis=0)
+            span = np.maximum(coordinates.max(axis=0) - minimum, 1e-12)
+            inner_margin = 46
+            self._render_positions = (
+                np.asarray([map_rect.left, map_rect.top])
+                + inner_margin
+                + (coordinates - minimum)
+                / span
+                * np.asarray(
+                    [
+                        map_rect.width - 2 * inner_margin,
+                        map_rect.height - 2 * inner_margin,
+                    ]
+                )
+            )
+            self._render_positions[:, 1] = map_rect.bottom - (
+                self._render_positions[:, 1] - map_rect.top
+            )
+        positions = self._render_positions
+
+        visited = self._visit_order[: self._step_count]
+        for source, target in zip(visited, visited[1:]):
+            pygame.draw.line(
+                canvas,
+                (45, 108, 223),
+                positions[source],
+                positions[target],
+                5,
+            )
+        if self._step_count == self.num_nodes:
+            pygame.draw.line(
+                canvas,
+                (45, 108, 223),
+                positions[visited[-1]],
+                positions[visited[0]],
+                5,
+            )
+
+        for index, position in enumerate(positions):
+            if index == self._current_node:
+                color = (245, 158, 11)
+                radius = 16
+            elif index == visited[0]:
+                color = (22, 163, 74)
+                radius = 14
+            elif self._visited[index]:
+                color = (45, 108, 223)
+                radius = 13
+            else:
+                color = (255, 255, 255)
+                radius = 13
+
+            pygame.draw.circle(canvas, (255, 255, 255), position, radius + 4)
+            pygame.draw.circle(canvas, color, position, radius)
+            pygame.draw.circle(canvas, (55, 65, 81), position, radius, width=2)
+            label_color = (255, 255, 255) if self._visited[index] else (55, 65, 81)
+            label = self._render_small_font.render(str(index), label_color)[0]
+            canvas.blit(label, label.get_rect(center=position))
+
+        legend_y = self.window_size - 42
+        legend_items = (
+            ((22, 163, 74), "Start"),
+            ((245, 158, 11), "Current"),
+            ((45, 108, 223), "Visited"),
+            ((255, 255, 255), "Unvisited"),
+        )
+        legend_x = 28
+        for color, text in legend_items:
+            pygame.draw.circle(canvas, color, (legend_x + 7, legend_y), 7)
+            pygame.draw.circle(canvas, (55, 65, 81), (legend_x + 7, legend_y), 7, 1)
+            legend = self._render_small_font.render(text, (55, 65, 81))[0]
+            canvas.blit(legend, (legend_x + 19, legend_y - 9))
+            legend_x += legend.get_width() + 48
+
+        if self.render_mode == "human":
+            self.window.blit(canvas, (0, 0))
+            pygame.event.pump()
+            pygame.display.update()
+            self.clock.tick(self.metadata["render_fps"])
+            return None
+        return np.transpose(pygame.surfarray.array3d(canvas), (1, 0, 2))
+
+    def close(self) -> None:
+        if self.window is not None:
+            import pygame
+
+            pygame.display.quit()
+            pygame.quit()
+            self.window = None
+            self.clock = None
+            self._render_font = None
+            self._render_small_font = None

RoutingGraphEnv/wrappers/__init__.py

@@ -0,0 +1,4 @@
+from RoutingGraphEnv.wrappers.clip_reward import ClipReward
+from RoutingGraphEnv.wrappers.discrete_actions import DiscreteActions
+from RoutingGraphEnv.wrappers.reacher_weighted_reward import ReacherRewardWrapper
+from RoutingGraphEnv.wrappers.relative_position import RelativePosition

RoutingGraphEnv/wrappers/clip_reward.py

@@ -0,0 +1,13 @@
+import gymnasium as gym
+import numpy as np
+
+
+class ClipReward(gym.RewardWrapper):
+    def __init__(self, env, min_reward, max_reward):
+        super().__init__(env)
+        self.min_reward = min_reward
+        self.max_reward = max_reward
+        self.reward_range = (min_reward, max_reward)
+
+    def reward(self, reward):
+        return np.clip(reward, self.min_reward, self.max_reward)

RoutingGraphEnv/wrappers/discrete_actions.py

@@ -0,0 +1,12 @@
+import gymnasium as gym
+from gymnasium.spaces import Discrete
+
+
+class DiscreteActions(gym.ActionWrapper):
+    def __init__(self, env, disc_to_cont):
+        super().__init__(env)
+        self.disc_to_cont = disc_to_cont
+        self.action_space = Discrete(len(disc_to_cont))
+
+    def action(self, act):
+        return self.disc_to_cont[act]

RoutingGraphEnv/wrappers/reacher_weighted_reward.py

@@ -0,0 +1,16 @@
+import gymnasium as gym
+
+
+class ReacherRewardWrapper(gym.Wrapper):
+    def __init__(self, env, reward_dist_weight, reward_ctrl_weight):
+        super().__init__(env)
+        self.reward_dist_weight = reward_dist_weight
+        self.reward_ctrl_weight = reward_ctrl_weight
+
+    def step(self, action):
+        obs, _, terminated, truncated, info = self.env.step(action)
+        reward = (
+            self.reward_dist_weight * info["reward_dist"]
+            + self.reward_ctrl_weight * info["reward_ctrl"]
+        )
+        return obs, reward, terminated, truncated, info

RoutingGraphEnv/wrappers/relative_position.py

@@ -0,0 +1,12 @@
+import gymnasium as gym
+from gymnasium.spaces import Box
+import numpy as np
+
+
+class RelativePosition(gym.ObservationWrapper):
+    def __init__(self, env):
+        super().__init__(env)
+        self.observation_space = Box(shape=(2,), low=-np.inf, high=np.inf)
+
+    def observation(self, obs):
+        return obs["target"] - obs["agent"]

routinggraphenv-0.0.1.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: RoutingGraphEnv
+Version: 0.0.1
+Summary: A Gymnasium environment for route optimization on OpenStreetMap road networks
+Project-URL: Homepage, https://github.com/TruongHaiDang/routing-graph
+Project-URL: Repository, https://github.com/TruongHaiDang/routing-graph.git
+Project-URL: Issues, https://github.com/TruongHaiDang/routing-graph/issues
+Author: Trương Hải Đăng
+License-Expression: MIT
+License-File: LICENSE
+Keywords: gymnasium,openstreetmap,reinforcement-learning,route-optimization,routing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: gymnasium
+Requires-Dist: osmnx
+Requires-Dist: pygame>=2.1.3
+Description-Content-Type: text/markdown
+
+# Gymnasium Examples
+Some simple examples of Gymnasium environments and wrappers.
+For some explanations of these examples, see the [Gymnasium documentation](https://gymnasium.farama.org).
+
+### Environments
+This repository hosts the examples that are shown [on the environment creation documentation](https://gymnasium.farama.org/tutorials/gymnasium_basics/environment_creation/).
+- `GridWorldEnv`: Simplistic implementation of gridworld environment
+
+### Wrappers
+This repository hosts the examples that are shown [on wrapper documentation](https://gymnasium.farama.org/api/wrappers/).
+- `ClipReward`: A `RewardWrapper` that clips immediate rewards to a valid range
+- `DiscreteActions`: An `ActionWrapper` that restricts the action space to a finite subset
+- `RelativePosition`: An `ObservationWrapper` that computes the relative position between an agent and a target
+- `ReacherRewardWrapper`: Allow us to weight the reward terms for the reacher environment
+
+### Contributing
+If you would like to contribute, follow these steps:
+- Fork this repository
+- Clone your fork
+- Set up pre-commit via `pre-commit install`
+
+PRs may require accompanying PRs in [the documentation repo](https://github.com/Farama-Foundation/Gymnasium/tree/main/docs).
+
+
+## Installation
+
+To install your new environment, run the following commands:
+
+```{shell}
+cd RoutingGraphEnv
+pip install -e .
+```
+
+## Upload to pypi.org
+
+Chạy tại thư mục project:
+
+```shell
+python3 -m build
+```
+
+Lệnh sẽ tạo thư mục `dist/` chứa file `.whl` và `.tar.gz`.
+
+Nếu chưa có module `build`:
+
+```shell
+python3 -m pip install build
+```
+
+Sau đó:
+
+```shell
+python3 -m twine upload dist/*
+```

routinggraphenv-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+RoutingGraphEnv/__init__.py,sha256=KgF0s__Vh2csHg35E9IYPJ1UIQKSrmA94Xn-UYdFUwk,160
+RoutingGraphEnv/envs/__init__.py,sha256=v8G1BgOS-ofiUYGS8LqRDHh93D0EpJwMcsJgrVpahyc,195
+RoutingGraphEnv/envs/openstreetmap_services.py,sha256=4UKyNbLnx3L6ko9LWFQ9P-tCgeKOaAtoVM9RjKsBtAA,2587
+RoutingGraphEnv/envs/routing_graph.py,sha256=3nPNNP9QqEJtGIHsIqlxsuX6CzYvOBjUpOjGd8ZcNiI,10240
+RoutingGraphEnv/wrappers/__init__.py,sha256=3PYxSCZ4lH1hzJfYrKTmoGUUBrIo7bVCTL7EncazT94,284
+RoutingGraphEnv/wrappers/clip_reward.py,sha256=bzJ1-WQMEHnmJomeIHA6Hp6gJ7Z2Gzob8VKanmo5B5w,388
+RoutingGraphEnv/wrappers/discrete_actions.py,sha256=da-6KuUtACdmF9JZHQNw60Y5pIoNl7c8WddW32zQTTI,342
+RoutingGraphEnv/wrappers/reacher_weighted_reward.py,sha256=Nz0dz6a7s33fiVjbJ1p-i0Gz7SlOlIWsmsH0REwqdOk,572
+RoutingGraphEnv/wrappers/relative_position.py,sha256=woiefV57IiBCGnTZ2zD30gnZw_mLmJJ-EdUEFybvwmI,337
+routinggraphenv-0.0.1.dist-info/METADATA,sha256=66hDMq-y5lxeOPqahppgfVYkP1vDfMt8Q26QIQ_6t0g,2692
+routinggraphenv-0.0.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+routinggraphenv-0.0.1.dist-info/licenses/LICENSE,sha256=_eBqWuxye5a0YySC8StPown-mJRIkM547tf5P_A1T1g,1078
+routinggraphenv-0.0.1.dist-info/RECORD,,

routinggraphenv-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

routinggraphenv-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2023 Farama Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.