RoutingGraphEnv 0.0.1__tar.gz

routinggraphenv-0.0.1/.github/workflows/publish-pypi.yml

@@ -0,0 +1,65 @@
+name: Publish to PyPI
+
+on:
+  pull_request:
+    branches:
+      - main
+    types:
+      - closed
+
+concurrency:
+  group: publish-pypi
+  cancel-in-progress: false
+
+jobs:
+  build:
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+      - name: Check out merged commit
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.merge_commit_sha }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: python -m pip install --upgrade build twine
+
+      - name: Build distributions
+        run: python -m build
+
+      - name: Check distributions
+        run: python -m twine check dist/*
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-distributions
+          path: dist/
+          if-no-files-found: error
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/RoutingGraphEnv
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Download distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: python-distributions
+          path: dist/
+
+      - name: Publish distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

routinggraphenv-0.0.1/.gitignore

@@ -0,0 +1,179 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/python
+
+cache/
+

routinggraphenv-0.0.1/.pre-commit-config.yaml

@@ -0,0 +1,11 @@
+---
+repos:
+  - repo: https://github.com/python/black
+    rev: 22.3.0
+    hooks:
+      - id: black
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    # Ruff version.
+    rev: v0.0.275
+    hooks:
+      - id: ruff

routinggraphenv-0.0.1/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.

routinggraphenv-0.0.1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,54 @@
+# 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/RoutingGraphEnv/__init__.py

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

routinggraphenv-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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-0.0.1/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/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["RoutingGraphEnv"]
+
+[project]
+name = "RoutingGraphEnv"
+version = "0.0.1"
+description = "A Gymnasium environment for route optimization on OpenStreetMap road networks"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "Trương Hải Đăng" },
+]
+keywords = [
+  "gymnasium",
+  "openstreetmap",
+  "reinforcement-learning",
+  "route-optimization",
+  "routing",
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Science/Research",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+  "gymnasium",
+  "osmnx",
+  "pygame>=2.1.3",
+]
+
+[project.urls]
+Homepage = "https://github.com/TruongHaiDang/routing-graph"
+Repository = "https://github.com/TruongHaiDang/routing-graph.git"
+Issues = "https://github.com/TruongHaiDang/routing-graph/issues"

routinggraphenv-0.0.1/requirements.txt

@@ -0,0 +1,3 @@
+gymnasium
+pygame
+osmnx

routinggraphenv-0.0.1/test.py

@@ -0,0 +1,47 @@
+import gymnasium as gym
+import RoutingGraphEnv  # Registers the environment with Gymnasium.
+from time import sleep
+from pprint import pprint
+
+
+env = gym.make(
+    "RoutingGraphEnv/RoutingGraph-v0",
+    place_name="Tan Binh District, Ho Chi Minh City, Vietnam",
+    num_nodes=10,
+    render_mode="human"
+)
+
+observation, info = env.reset(seed=42)
+
+terminated = False
+truncated = False
+
+while not terminated and not truncated:
+    action = env.action_space.sample(mask=env.unwrapped.action_masks())
+
+    observation, reward, terminated, truncated, info = env.step(action)
+    print("observation")
+    pprint(observation)
+    print("reward")
+    pprint(reward)
+    print("terminated")
+    pprint(terminated)
+    print("truncated")
+    pprint(truncated)
+    print("info")
+    pprint(info)
+
+    print(
+        {
+            "action": action,
+            "reward": reward,
+            "terminated": terminated,
+            "truncated": truncated,
+            "observation": observation,
+            "info": info,
+        }
+    )
+    print("-"*100)
+    sleep(1)
+
+env.close()