reignite 0.1.0__tar.gz

reignite-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Oğuzhan
+
+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.

reignite-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: reignite
+Version: 0.1.0
+Summary: Modern Procedural Generation for Gazebo
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Provides-Extra: publish
+Requires-Dist: build; extra == "publish"
+Requires-Dist: twine; extra == "publish"
+Dynamic: license-file
+
+# reignite
+Modern Procedural Generation for Gazebo
+
+## SDF Reader
+
+Parse an SDF XML file and instantiate the correct versioned model:
+
+```python
+from reignite import read_sdf
+
+world = read_sdf("path/to/world.sdf")
+```
+
+If the file has multiple top-level elements under `<sdf>`, pick one:
+
+```python
+from reignite import read_sdf
+
+model = read_sdf("path/to/file.sdf", tag_name="model")
+```
+
+## Tests
+
+```bash
+./scripts/run_tests.sh
+```

reignite-0.1.0/README.md

@@ -0,0 +1,26 @@
+# reignite
+Modern Procedural Generation for Gazebo
+
+## SDF Reader
+
+Parse an SDF XML file and instantiate the correct versioned model:
+
+```python
+from reignite import read_sdf
+
+world = read_sdf("path/to/world.sdf")
+```
+
+If the file has multiple top-level elements under `<sdf>`, pick one:
+
+```python
+from reignite import read_sdf
+
+model = read_sdf("path/to/file.sdf", tag_name="model")
+```
+
+## Tests
+
+```bash
+./scripts/run_tests.sh
+```

reignite-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "reignite"
+version = "0.1.0"
+description = "Modern Procedural Generation for Gazebo"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+
+[project.optional-dependencies]
+test = ["pytest>=7"]
+publish = ["build", "twine"]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

reignite-0.1.0/setup.cfg

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

reignite-0.1.0/src/reignite/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from .reader import read_sdf, read_sdf_string
+
+__all__ = ["read_sdf", "read_sdf_string"]
+

reignite-0.1.0/src/reignite/reader.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import importlib
+from pathlib import Path
+from typing import Optional
+from xml.etree import ElementTree as ET
+
+
+def _version_dir_name(version: str) -> str:
+    return "sdf" + version.replace(".", "_")
+
+
+def _normalize_version(version: str) -> str:
+    return version.replace("_", ".")
+
+
+def _load_version_module(version: str):
+    version = _normalize_version(version)
+    module_name = f"reignite.sdf.{_version_dir_name(version)}"
+    return importlib.import_module(module_name)
+
+
+def _select_root_element(root: ET.Element, tag_name: Optional[str]) -> tuple[str, ET.Element]:
+    if root.tag != "sdf":
+        return root.tag, root
+
+    children = [c for c in root if isinstance(c.tag, str)]
+    if not children:
+        raise ValueError("SDF root contains no element children.")
+
+    if tag_name:
+        for child in children:
+            if child.tag == tag_name:
+                return child.tag, child
+        raise ValueError(f"Tag '{tag_name}' not found under <sdf>. Found: {[c.tag for c in children]}")
+
+    if len(children) != 1:
+        raise ValueError(
+            "SDF root contains multiple top-level elements; pass tag_name to choose one: "
+            f"{[c.tag for c in children]}"
+        )
+    return children[0].tag, children[0]
+
+
+def _resolve_tag_class(module, tag: str):
+    get_tag_class = getattr(module, "get_tag_class", None)
+    if callable(get_tag_class):
+        return get_tag_class(tag)
+
+    models = getattr(module, "models", None)
+    if models is None:
+        return None
+
+    tag_names = getattr(models, "TAG_NAMES", [])
+    tag_map = {name: getattr(models, _to_classname(name)) for name in tag_names}
+    return tag_map.get(tag)
+
+
+def _to_classname(s: str) -> str:
+    return "".join(p.capitalize() for p in s.replace("-", "_").split("_"))
+
+
+def read_sdf_from_element(root: ET.Element, tag_name: Optional[str] = None):
+    version = root.get("version")
+    if not version:
+        raise ValueError("SDF version attribute not found on root element.")
+
+    tag, element = _select_root_element(root, tag_name)
+    module = _load_version_module(version)
+    tag_class = _resolve_tag_class(module, tag)
+    if tag_class is None:
+        available = sorted(getattr(module, "TAG_CLASS_MAP", {}).keys())
+        raise ValueError(f"Tag '{tag}' not supported for version {version}. Available: {available}")
+
+    return tag_class.from_sdf(element)
+
+
+def read_sdf(source: str | Path, tag_name: Optional[str] = None):
+    return read_sdf_from_element(ET.parse(Path(source)).getroot(), tag_name)
+
+
+def read_sdf_string(xml_text: str, tag_name: Optional[str] = None):
+    return read_sdf_from_element(ET.fromstring(xml_text), tag_name)

reignite-0.1.0/src/reignite/sdf/sdf1_0/__init__.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from . import models as _models
+
+Actor = _models.Actor
+Camera = _models.Camera
+Collision = _models.Collision
+Contact = _models.Contact
+Gazebo = _models.Gazebo
+Geometry = _models.Geometry
+Gripper = _models.Gripper
+Gui = _models.Gui
+Inertial = _models.Inertial
+Joint = _models.Joint
+Light = _models.Light
+Link = _models.Link
+Model = _models.Model
+Physics = _models.Physics
+Plugin = _models.Plugin
+Projector = _models.Projector
+Ray = _models.Ray
+Rfid = _models.Rfid
+Rfidtag = _models.Rfidtag
+Road = _models.Road
+Scene = _models.Scene
+Sensor = _models.Sensor
+State = _models.State
+Surface = _models.Surface
+Visual = _models.Visual
+World = _models.World
+
+TAG_NAMES: list[str] = ["actor", "camera", "collision", "contact", "gazebo", "geometry", "gripper", "gui", "inertial", "joint", "light", "link", "model", "physics", "plugin", "projector", "ray", "rfid", "rfidtag", "road", "scene", "sensor", "state", "surface", "visual", "world"]
+TAG_CLASS_MAP: dict[str, type] = {
+    "actor": Actor,
+    "camera": Camera,
+    "collision": Collision,
+    "contact": Contact,
+    "gazebo": Gazebo,
+    "geometry": Geometry,
+    "gripper": Gripper,
+    "gui": Gui,
+    "inertial": Inertial,
+    "joint": Joint,
+    "light": Light,
+    "link": Link,
+    "model": Model,
+    "physics": Physics,
+    "plugin": Plugin,
+    "projector": Projector,
+    "ray": Ray,
+    "rfid": Rfid,
+    "rfidtag": Rfidtag,
+    "road": Road,
+    "scene": Scene,
+    "sensor": Sensor,
+    "state": State,
+    "surface": Surface,
+    "visual": Visual,
+    "world": World,
+}
+
+def get_tag_class(tag: str) -> type | None:
+    return TAG_CLASS_MAP.get(tag)

reignite-0.1.0/src/reignite/sdf/sdf1_0/model.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from xml.etree import ElementTree as ET
+
+
+class Model:
+    def to_sdf(self) -> ET.Element:
+        raise NotImplementedError
+
+    @classmethod
+    def from_sdf(cls, el: ET.Element) -> "Model":
+        raise NotImplementedError

reignite-0.1.0/src/reignite/sdf/sdf1_0/models/__init__.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from .actor import Actor
+from .camera import Camera
+from .collision import Collision
+from .contact import Contact
+from .gazebo import Gazebo
+from .geometry import Geometry
+from .gripper import Gripper
+from .gui import Gui
+from .inertial import Inertial
+from .joint import Joint
+from .light import Light
+from .link import Link
+from .model import Model
+from .physics import Physics
+from .plugin import Plugin
+from .projector import Projector
+from .ray import Ray
+from .rfid import Rfid
+from .rfidtag import Rfidtag
+from .road import Road
+from .scene import Scene
+from .sensor import Sensor
+from .state import State
+from .surface import Surface
+from .visual import Visual
+from .world import World
+
+TAG_NAMES: list[str] = ["actor", "camera", "collision", "contact", "gazebo", "geometry", "gripper", "gui", "inertial", "joint", "light", "link", "model", "physics", "plugin", "projector", "ray", "rfid", "rfidtag", "road", "scene", "sensor", "state", "surface", "visual", "world"]

reignite-0.1.0/src/reignite/sdf/sdf1_0/models/actor.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from xml.etree import ElementTree as ET
+
+from typing import List
+
+from ..model import Model
+from .link import Link
+from .joint import Joint
+from .plugin import Plugin
+from .origin import Origin
+from .skin import Skin
+from .animation import Animation
+from .script import Script
+
+
+class Actor(Model):
+    def __init__(
+        self,
+        name: str = "__default__",
+        static: bool = False,
+        link: List["Link"] = None,
+        joint: List["Joint"] = None,
+        plugin: List["Plugin"] = None,
+        origin: "Origin" = None,
+        skin: "Skin" = None,
+        animation: List["Animation"] = None,
+        script: "Script" = None
+    ):
+        self.name = name
+        self.static = static
+        self.link = link or []
+        self.joint = joint or []
+        self.plugin = plugin or []
+        self.origin = origin
+        self.skin = skin
+        self.animation = animation or []
+        self.script = script
+
+    def to_sdf(self) -> ET.Element:
+        el = ET.Element("actor")
+        if self.name is not None:
+            el.set("name", self.name)
+        if self.static is not None:
+            el.set("static", str(self.static).lower())
+        for item in (self.link or []):
+            el.append(item.to_sdf())
+        for item in (self.joint or []):
+            el.append(item.to_sdf())
+        for item in (self.plugin or []):
+            el.append(item.to_sdf())
+        if self.origin is not None:
+            el.append(self.origin.to_sdf())
+        if self.skin is not None:
+            el.append(self.skin.to_sdf())
+        for item in (self.animation or []):
+            el.append(item.to_sdf())
+        if self.script is not None:
+            el.append(self.script.to_sdf())
+        return el
+
+    @classmethod
+    def from_sdf(cls, el: ET.Element) -> "Actor":
+        _name = el.get("name", "__default__")
+        _static = el.get("static", False).strip().lower() == 'true'
+        _link = [Link.from_sdf(c) for c in el.findall("link")]
+        _joint = [Joint.from_sdf(c) for c in el.findall("joint")]
+        _plugin = [Plugin.from_sdf(c) for c in el.findall("plugin")]
+        _c_origin = el.find("origin")
+        _origin = Origin.from_sdf(_c_origin) if _c_origin is not None else None
+        _c_skin = el.find("skin")
+        _skin = Skin.from_sdf(_c_skin) if _c_skin is not None else None
+        _animation = [Animation.from_sdf(c) for c in el.findall("animation")]
+        _c_script = el.find("script")
+        _script = Script.from_sdf(_c_script) if _c_script is not None else None
+        return cls(name=_name, static=_static, link=_link, joint=_joint, plugin=_plugin, origin=_origin, skin=_skin, animation=_animation, script=_script)

reignite-0.1.0/src/reignite/sdf/sdf1_0/models/ambient.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from xml.etree import ElementTree as ET
+
+from ..model import Model
+from ....utils.color import Color
+
+
+class Ambient(Model):
+    def __init__(self, rgba: Color = None):
+        if rgba is None:
+            rgba = Color.from_sdf("0 0 0 1")
+        self.rgba = rgba
+
+    def to_sdf(self) -> ET.Element:
+        el = ET.Element("ambient")
+        if self.rgba is not None:
+            el.set("rgba", self.rgba.to_sdf())
+        return el
+
+    @classmethod
+    def from_sdf(cls, el: ET.Element) -> "Ambient":
+        _rgba = Color.from_sdf(el.get("rgba", "0 0 0 1"))
+        return cls(rgba=_rgba)

reignite-0.1.0/src/reignite/sdf/sdf1_0/models/angular.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from xml.etree import ElementTree as ET
+
+from ..model import Model
+
+
+import math
+import sys
+
+def _parse_int32(raw: str) -> int:
+    v = int(raw)
+    if not (-2147483648 <= v <= 2147483647):
+        raise ValueError(f"int32 out of range: {v}")
+    return v
+
+
+def _parse_uint32(raw: str) -> int:
+    v = int(raw)
+    if not (0 <= v <= 4294967295):
+        raise ValueError(f"uint32 out of range: {v}")
+    return v
+
+
+def _parse_double(raw: str) -> float:
+    v = float(raw)
+    if not math.isfinite(v) or abs(v) > 1.7976931348623157e+308:
+        raise ValueError(f"double out of range: {raw}")
+    return v
+
+
+
+class Angular(Model):
+    def __init__(self, angular: float = 0.0):
+        self.angular = angular
+
+    def to_sdf(self) -> ET.Element:
+        el = ET.Element("angular")
+        if self.angular is not None:
+            el.text = str(self.angular)
+        return el
+
+    @classmethod
+    def from_sdf(cls, el: ET.Element) -> "Angular":
+        _text = el.text or 0.0
+        _angular = _parse_double(_text)
+        return cls(angular=_angular)

reignite-0.1.0/src/reignite/sdf/sdf1_0/models/animation.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from xml.etree import ElementTree as ET
+
+from ..model import Model
+
+
+import math
+import sys
+
+def _parse_int32(raw: str) -> int:
+    v = int(raw)
+    if not (-2147483648 <= v <= 2147483647):
+        raise ValueError(f"int32 out of range: {v}")
+    return v
+
+
+def _parse_uint32(raw: str) -> int:
+    v = int(raw)
+    if not (0 <= v <= 4294967295):
+        raise ValueError(f"uint32 out of range: {v}")
+    return v
+
+
+def _parse_double(raw: str) -> float:
+    v = float(raw)
+    if not math.isfinite(v) or abs(v) > 1.7976931348623157e+308:
+        raise ValueError(f"double out of range: {raw}")
+    return v
+
+
+
+class Animation(Model):
+    def __init__(
+        self,
+        name: str = "__default__",
+        filename: str = "__default__",
+        scale: float = 1.0,
+        interpolate_x: bool = False
+    ):
+        self.name = name
+        self.filename = filename
+        self.scale = scale
+        self.interpolate_x = interpolate_x
+
+    def to_sdf(self) -> ET.Element:
+        el = ET.Element("animation")
+        if self.name is not None:
+            el.set("name", self.name)
+        if self.filename is not None:
+            el.set("filename", self.filename)
+        if self.scale is not None:
+            el.set("scale", str(self.scale))
+        if self.interpolate_x is not None:
+            el.set("interpolate_x", str(self.interpolate_x).lower())
+        return el
+
+    @classmethod
+    def from_sdf(cls, el: ET.Element) -> "Animation":
+        _name = el.get("name", "__default__")
+        _filename = el.get("filename", "__default__")
+        _scale = _parse_double(el.get("scale", 1.0))
+        _interpolate_x = el.get("interpolate_x", False).strip().lower() == 'true'
+        return cls(name=_name, filename=_filename, scale=_scale, interpolate_x=_interpolate_x)

reignite-0.1.0/src/reignite/sdf/sdf1_0/models/attenuation.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from xml.etree import ElementTree as ET
+
+from ..model import Model
+
+
+import math
+import sys
+
+def _parse_int32(raw: str) -> int:
+    v = int(raw)
+    if not (-2147483648 <= v <= 2147483647):
+        raise ValueError(f"int32 out of range: {v}")
+    return v
+
+
+def _parse_uint32(raw: str) -> int:
+    v = int(raw)
+    if not (0 <= v <= 4294967295):
+        raise ValueError(f"uint32 out of range: {v}")
+    return v
+
+
+def _parse_double(raw: str) -> float:
+    v = float(raw)
+    if not math.isfinite(v) or abs(v) > 1.7976931348623157e+308:
+        raise ValueError(f"double out of range: {raw}")
+    return v
+
+
+
+class Attenuation(Model):
+    def __init__(
+        self,
+        range: float = 10,
+        linear: float = 1,
+        constant: float = 1,
+        quadratic: float = 0
+    ):
+        self.range = range
+        self.linear = linear
+        self.constant = constant
+        self.quadratic = quadratic
+
+    def to_sdf(self) -> ET.Element:
+        el = ET.Element("attenuation")
+        if self.range is not None:
+            el.set("range", str(self.range))
+        if self.linear is not None:
+            el.set("linear", str(self.linear))
+        if self.constant is not None:
+            el.set("constant", str(self.constant))
+        if self.quadratic is not None:
+            el.set("quadratic", str(self.quadratic))
+        return el
+
+    @classmethod
+    def from_sdf(cls, el: ET.Element) -> "Attenuation":
+        _range = _parse_double(el.get("range", 10))
+        _linear = _parse_double(el.get("linear", 1))
+        _constant = _parse_double(el.get("constant", 1))
+        _quadratic = _parse_double(el.get("quadratic", 0))
+        return cls(range=_range, linear=_linear, constant=_constant, quadratic=_quadratic)

reignite-0.1.0/src/reignite/sdf/sdf1_0/models/axis.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from xml.etree import ElementTree as ET
+
+from ..model import Model
+from ....utils.vector3 import Vector3
+from .dynamics import Dynamics
+from .limit import Limit
+
+
+class Axis(Model):
+    def __init__(self, xyz: Vector3 = None, dynamics: "Dynamics" = None, limit: "Limit" = None):
+        if xyz is None:
+            xyz = Vector3.from_sdf("0 0 1")
+        self.xyz = xyz
+        self.dynamics = dynamics
+        self.limit = limit
+
+    def to_sdf(self) -> ET.Element:
+        el = ET.Element("axis")
+        if self.xyz is not None:
+            el.set("xyz", self.xyz.to_sdf())
+        if self.dynamics is not None:
+            el.append(self.dynamics.to_sdf())
+        if self.limit is not None:
+            el.append(self.limit.to_sdf())
+        return el
+
+    @classmethod
+    def from_sdf(cls, el: ET.Element) -> "Axis":
+        _xyz = Vector3.from_sdf(el.get("xyz", "0 0 1"))
+        _c_dynamics = el.find("dynamics")
+        _dynamics = Dynamics.from_sdf(_c_dynamics) if _c_dynamics is not None else None
+        _c_limit = el.find("limit")
+        _limit = Limit.from_sdf(_c_limit) if _c_limit is not None else None
+        return cls(xyz=_xyz, dynamics=_dynamics, limit=_limit)

reignite-0.1.0/src/reignite/sdf/sdf1_0/models/axis2.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from xml.etree import ElementTree as ET
+
+from ..model import Model
+from ....utils.vector3 import Vector3
+from .dynamics import Dynamics
+from .limit import Limit
+
+
+class Axis2(Model):
+    def __init__(self, xyz: Vector3 = None, dynamics: "Dynamics" = None, limit: "Limit" = None):
+        if xyz is None:
+            xyz = Vector3.from_sdf("0 0 1")
+        self.xyz = xyz
+        self.dynamics = dynamics
+        self.limit = limit
+
+    def to_sdf(self) -> ET.Element:
+        el = ET.Element("axis2")
+        if self.xyz is not None:
+            el.set("xyz", self.xyz.to_sdf())
+        if self.dynamics is not None:
+            el.append(self.dynamics.to_sdf())
+        if self.limit is not None:
+            el.append(self.limit.to_sdf())
+        return el
+
+    @classmethod
+    def from_sdf(cls, el: ET.Element) -> "Axis2":
+        _xyz = Vector3.from_sdf(el.get("xyz", "0 0 1"))
+        _c_dynamics = el.find("dynamics")
+        _dynamics = Dynamics.from_sdf(_c_dynamics) if _c_dynamics is not None else None
+        _c_limit = el.find("limit")
+        _limit = Limit.from_sdf(_c_limit) if _c_limit is not None else None
+        return cls(xyz=_xyz, dynamics=_dynamics, limit=_limit)