spatialdds-ros 0.3.0__py3-none-any.whl

spatialdds_ros/transport.py

@@ -0,0 +1,170 @@
+"""
+Endpoints, with the §3.3.3 QoS actually applied.
+
+Thin on purpose, with two jobs. Every endpoint this library creates goes
+through one place that resolves a profile name to a `Qos`, so the profiles in
+`qos.py` are true on the wire rather than decorative; and every read goes
+through one place that knows `take()` returns lifecycle notifications as well
+as payloads. Both are the kind of rule that is wrong in one spot or wrong
+everywhere, and one enforcement point is the difference. The prototype's
+`typed_transport` exists for the same reasons and this follows its shape.
+"""
+from __future__ import annotations
+
+from typing import Any, List, NamedTuple, Optional, Type
+
+from cyclonedds.core import InstanceState
+from cyclonedds.domain import DomainParticipant
+from cyclonedds.pub import DataWriter, Publisher
+from cyclonedds.sub import DataReader, Subscriber
+from cyclonedds.topic import Topic
+
+from spatialdds_ros.qos import PROFILES, QosProfile
+
+
+class UnknownQosProfile(KeyError):
+    """A profile name that is not one of the three this library uses."""
+
+
+def _profile(name: str) -> QosProfile:
+    try:
+        return PROFILES[name]
+    except KeyError:
+        raise UnknownQosProfile(
+            f"{name!r} is not a profile this library carries; expected one of "
+            f"{', '.join(sorted(PROFILES))}") from None
+
+
+def _topic(participant: DomainParticipant, topic_name: str,
+           datatype: Type) -> Topic:
+    """
+    The topic, with **default QoS**. The profile rides on the endpoints.
+
+    A `Topic` object's QoS must be identical for every creation of the same
+    name within a participant: DDS refuses the second with
+    `DDS_RETCODE_INCONSISTENT_POLICY`, and the refusal lands on whichever
+    endpoint happened to be constructed later, which makes it look like a
+    problem with that endpoint rather than with the pair.
+
+    That makes topic QoS a contract between **every participant in the
+    process**, not a property of this library's lanes — and nothing in this
+    API said so. The first real consumer paid for it. SpatialDDS-demo applies
+    the same §3.3.3 profiles to endpoints only; it asked for an entity reader
+    on a topic this library had already created carrying the profile, and was
+    refused. Both conventions are legal DDS. They are not legal together, and
+    the library had quietly made itself the one that must be matched.
+
+    So it now asks for the least it can: the default, which is what any
+    participant that passes no QoS gets, including every ROS and DDS example.
+
+    Nothing leaves the wire. Matching is a reader/writer negotiation over
+    *endpoint* QoS — a topic's QoS enters it only as a default for endpoints
+    that ask for one, and these never do; both are always given the profile
+    explicitly. `test_transport.py` pins both halves: that the policies still
+    reach the endpoints, and that a library writer still exchanges with a
+    reader built the other convention's way.
+
+    Lifespan was excluded here for this exact reason on 2026-10-18, one policy
+    at a time, when an announce writer with a `ttl_sec` failed against a reader
+    opened first. This is that lesson finished.
+    """
+    return Topic(participant, topic_name, datatype)
+
+
+def make_writer(participant: DomainParticipant, topic_name: str,
+                datatype: Type, qos_profile: str, *,
+                lifespan_sec: Optional[float] = None) -> DataWriter:
+    profile = _profile(qos_profile)
+    topic = _topic(participant, topic_name, datatype)
+    writer_qos = profile.to_qos(lifespan_sec=lifespan_sec)
+    return DataWriter(Publisher(participant, qos=profile.to_qos()), topic,
+                      qos=writer_qos)
+
+
+def make_reader(participant: DomainParticipant, topic_name: str,
+                datatype: Type, qos_profile: str) -> DataReader:
+    profile = _profile(qos_profile)
+    topic = _topic(participant, topic_name, datatype)
+    return DataReader(Subscriber(participant, qos=profile.to_qos()), topic,
+                      qos=profile.to_qos())
+
+
+STATE_NAMES = {int(InstanceState.Alive): "ALIVE",
+               int(InstanceState.NotAliveDisposed): "NOT_ALIVE_DISPOSED",
+               int(InstanceState.NotAliveNoWriters): "NOT_ALIVE_NO_WRITERS"}
+
+
+class TakenSample(NamedTuple):
+    """
+    A sample and what the middleware said about its instance.
+
+    `data` is `None` for a lifecycle notification — a dispose or a
+    writer-gone — which carries instance state and no payload. It is *not*
+    the only way a not-alive state arrives: a valid sample that has not been
+    read when its writer disposes carries the state on its own `sample_info`
+    instead, and no separate notification is generated. So `data` and `alive`
+    are independent, and a caller that wants the lifecycle must read `alive`
+    rather than infer it from a missing payload.
+    """
+    data: Optional[Any]
+    alive: bool
+    instance_handle: Optional[int]
+    instance_state: Any
+
+    @property
+    def state_name(self) -> str:
+        """For logs. `instance_state` is a plain int, not an enum member."""
+        return STATE_NAMES.get(int(self.instance_state),
+                               f"UNKNOWN({int(self.instance_state)})")
+
+
+def take_with_state(reader: DataReader, *, n: int = 100) -> List[TakenSample]:
+    """
+    Samples **and their instance state**, so a caller can act on disposal.
+
+    CycloneDDS's `take()` does not return payloads only. It also yields
+    `InvalidSample` objects — dispose and no-writer notifications, carrying
+    `sample_info` with `valid_data == False` and no fields of the datatype at
+    all. A read that assumes every sample is a payload reads an attribute off
+    one and raises.
+    """
+    out: List[TakenSample] = []
+    for sample in (reader.take(N=n) or []):
+        if sample is None:
+            continue
+        info = getattr(sample, "sample_info", None)
+        valid = bool(getattr(info, "valid_data", True)) if info else True
+        state = (getattr(info, "instance_state", InstanceState.Alive)
+                 if info else InstanceState.Alive)
+        out.append(TakenSample(
+            data=sample if valid else None,
+            alive=valid and state == InstanceState.Alive,
+            instance_handle=getattr(info, "instance_handle", None) if info
+            else None,
+            instance_state=state))
+    return out
+
+
+def take_samples(reader: DataReader, *, n: int = 100) -> List[Any]:
+    """
+    Payloads only — lifecycle notifications dropped, not mistaken for one.
+
+    Disposal is not a signal this library *acts* on: the adapter owns exactly
+    one key and never disposes it, and going quiet is reported as `UNOBSERVED`,
+    which is a weaker statement than "this robot is gone". But not acting on
+    an event is not the same as not receiving it, and this filtered only
+    `None` until 2026-10-19 — so the first peer that joined a lane and left
+    killed the robot reading it:
+
+        AttributeError: 'InvalidSample' object has no attribute 'subject_id'
+
+    Two call sites, both reached by an ordinary deployment. `poll_commands`
+    crashed when any requester's participant went away; `already_published`
+    would have crashed at startup on the tombstone of the robot that ran
+    before it — and a tombstone must not count as a live conflict either,
+    which it now cannot, because it never arrives as a record.
+
+    Nothing in this library's 153 tests produced one: every writer outlived
+    every reader. `test_transport.py` now keeps a peer that dies.
+    """
+    return [s.data for s in take_with_state(reader, n=n) if s.data is not None]

spatialdds_ros-0.3.0.data/data/share/spatialdds_ros/package.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0"?>
+<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://relaxng.org/ns/structure/1.0"?>
+<package format="3">
+  <name>spatialdds_ros</name>
+  <version>0.3.0</version>
+  <description>
+    Makes a ROS 2 robot a SpatialDDS participant: its pose published as a
+    spatial.owm entity on scene-scoped topics, goto commands consumed from
+    ModelCommand and dispatched to nav2, and its presence announced — on the
+    same DDS bus ROS already runs on. A type adapter on a shared bus, not a
+    protocol gateway.
+  </description>
+  <maintainer email="fiberhog@gmail.com">James Jackson</maintainer>
+  <license>MIT</license>
+
+  <buildtool_depend>ament_python</buildtool_depend>
+
+  <exec_depend>rclpy</exec_depend>
+  <exec_depend>geometry_msgs</exec_depend>
+  <exec_depend>nav_msgs</exec_depend>
+  <exec_depend>nav2_msgs</exec_depend>
+  <exec_depend>tf2_ros</exec_depend>
+
+  <test_depend>python3-pytest</test_depend>
+
+  <export>
+    <build_type>ament_python</build_type>
+  </export>
+</package>

spatialdds_ros-0.3.0.dist-info/METADATA

@@ -0,0 +1,331 @@
+Metadata-Version: 2.4
+Name: spatialdds-ros
+Version: 0.3.0
+Summary: A ROS 2 robot as a SpatialDDS participant
+Home-page: https://github.com/OpenArCloud/spatialdds-ros
+Author: Open AR Cloud
+Maintainer: James Jackson
+Maintainer-email: fiberhog@gmail.com
+License: MIT
+Project-URL: Source, https://github.com/OpenArCloud/spatialdds-ros
+Project-URL: Issues, https://github.com/OpenArCloud/spatialdds-ros/issues
+Project-URL: Changelog, https://github.com/OpenArCloud/spatialdds-ros/releases
+Keywords: spatialdds,ros2,dds,robotics,nav2,digital-twin,spatial-computing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cyclonedds>=0.10
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# spatialdds_ros
+
+Make a ROS 2 robot a SpatialDDS participant: its pose published as a
+`spatial.owm` entity on scene-scoped topics, `goto` commands consumed from
+`ModelCommand` and dispatched to nav2, and its presence announced — all on the
+same DDS bus ROS already runs on.
+
+**A type adapter on a shared bus, not a protocol gateway.** Nothing is
+relayed. ROS and SpatialDDS meet on the wire because both are DDS, so this is
+one process holding both stacks, publishing the model as model and reading ROS
+as ROS.
+
+## Installing, and what you are not installing
+
+```sh
+pip install spatialdds-ros
+```
+
+That gets `cyclonedds` and nothing else. **No ROS.** The library puts a robot
+on a SpatialDDS bus, reads commands off it and drives a navigator, and none of
+that needs a ROS install — so `rclpy` is not a dependency, and the absence is
+deliberate rather than an omission waiting to be tidied up.
+
+The split runs through the whole package:
+
+| dependency | declared in | what it is for |
+|---|---|---|
+| `cyclonedds` | `install_requires` | the bus. Everything here needs it |
+| `rclpy`, `tf2_ros`, `nav2_msgs` | `package.xml` | the ROS node alone, resolved by `rosdep`, never by pip |
+
+Only `spatialdds_ros.robot_node` requires a ROS 2 environment. It imports
+`rclpy` inside its entry point rather than at module scope, which is what
+lets the other twelve modules — and the entire test suite — run on a machine
+that has never had ROS installed.
+
+**That claim is a gate, not a promise.**
+[`test/test_no_ros_needed.py`](https://github.com/OpenArCloud/spatialdds-ros/blob/main/test/test_no_ros_needed.py)
+walks every module reachable from `import spatialdds_ros` and fails on a
+module-scope `import rclpy` anywhere in it. By source inspection, so it
+catches the violation on a ROS workstation where the import would have
+succeeded — a test that only checked "the import worked" would pass there and
+fail in CI. If the split ever stops being real, that is where it is reported.
+
+## A robot on the bus, with no robot
+
+No ROS, no nav2, no hardware:
+
+```sh
+pip install -e .
+python3 -m spatialdds_ros.standalone \
+    --scene bare-scene \
+    --entity-id ent:robot:r1 \
+    --frame-id map/bare-scene
+```
+
+```
+robot: scene bare-scene, entity ent:robot:r1 in frame map/bare-scene, DDS domain 0
+robot: no anchor configured, so this adapter publishes no FrameTransform: its
+       entity and poses are on the bus and complete, and it makes no claim
+       about where that frame sits on the earth. Another participant may own
+       that claim — a venue publishing its own georeference is the ordinary
+       case, and then this is the correct configuration. If nobody publishes
+       one, a consumer cannot place this robot on a globe and should say so
+       rather than assume a position
+robot: announce: svc:robot:r1 as OTHER, 3 topics, ttl 300s
+```
+
+It is now on three lanes, and discoverable on a fourth:
+
+| lane | topic | QoS |
+|---|---|---|
+| what exists | `spatialdds/bare-scene/world/entity/v1` | `MODEL_LATCHED` |
+| where it is | `spatialdds/bare-scene/world/model_pose/v1` | `MODEL_FAST` |
+| what to do | `spatialdds/bare-scene/world/model_command/v1` | `MODEL_COMMAND` |
+| who it is | `spatialdds/discovery/announce/v1` | `MODEL_LATCHED` |
+
+Add `--bounds -10,-10,10,10` and it will refuse a goal that leaves the box, so
+the refusal path can be exercised without hardware.
+
+## On a real robot
+
+```sh
+ros2 run spatialdds_ros robot_node --ros-args \
+    -p scene:=bare-scene \
+    -p entity_id:=ent:robot:r1 \
+    -p frame_id:=map/bare-scene
+```
+
+The pose input defaults to the TF chain `map -> base_link`. That default
+matters: it is what nav2 itself consumes, it works whatever the localizer is,
+and it assumes no topic name. `pose_source:=amcl` and `pose_source:=odom` are
+available, and `odom` logs its own consequence — odom drifts against map, so
+publishing it as a georeferenced pose is correct only where `map -> odom` is
+static and identity, which is a simulator and not a localizing robot.
+
+`ROS 2 Humble` and `Jazzy` are the named targets. **The ROS buildfarm is
+deferred** — there is no released binary package; install from source or with
+pip.
+
+## Configuration
+
+Three parameters have no default and the node refuses to start without them,
+because every possible default would be a false statement about the world:
+
+| parameter | why there is no default |
+|---|---|
+| `scene` | which world this robot is in. A wrong scene is an empty bus, not an error |
+| `entity_id` | which robot it is. A default collides the moment a second one runs |
+| `frame_id` | which frame its pose is in. A pose without its frame is meaningless |
+
+Everything else has one: `domain` 0, `ground_z` 0.0, `pose_source` tf,
+`nav2_action` navigate_to_pose, `source_id` derived from `entity_id`,
+`content_refs` and `external_refs` empty.
+
+### What the robot *is*, and what it is *also known as*
+
+```sh
+python3 -m spatialdds_ros.standalone \
+    --scene bare-scene --entity-id ent:robot:r1 --frame-id map/bare-scene \
+    --content-ref catalog:dcef7c31-1d5f-54aa-9344-899912f9d34a \
+    --external-ref wikidata=Q4810574
+```
+
+`content_refs` is how a consumer finds out what to *draw*. A client that reads
+a `catalog:` reference can resolve the model behind it; without one it has
+nothing to resolve and will render a marker. That is not a bug in the client —
+it is the honest rendering of a robot that has not said what it looks like.
+
+`external_refs` is what it is also known as: a wikidata id, an
+asset-management number, a fleet number.
+
+**Both are empty unless configured, and empty is a statement.** The adapter
+publishes what the operator told it and nothing else — it invents no reference
+and guesses no asset, because a reference nobody authorised is a claim on
+nobody's authority. An empty sequence says "this robot names no content"; it
+is not an accident of omission, and `test/test_adapter.py` asserts both
+directions.
+
+On a ROS robot the same two are string-array parameters, with `external_refs`
+as `key=value` entries:
+
+```sh
+ros2 run spatialdds_ros robot_node --ros-args \
+    -p scene:=bare-scene -p entity_id:=ent:robot:r1 \
+    -p frame_id:=map/bare-scene \
+    -p content_refs:='[catalog:dcef7c31-1d5f-54aa-9344-899912f9d34a]' \
+    -p external_refs:='[wikidata=Q4810574]'
+```
+
+### Property keys
+
+The adapter publishes two entity properties, and these names are **the
+convention** rather than this library's private spelling — a consumer should
+be able to read any `spatialdds_ros` robot without diffing two records to
+discover what they are called:
+
+| key | meaning |
+|---|---|
+| `label` | the human-facing name, from `label` or the `entity_id`'s tail |
+| `nav.status` | what became of the last goal, held until a new one is accepted |
+
+Unprefixed on purpose. An earlier consumer had published `demo.label` and
+`demo.nav_status`, which scoped a general fact to one deployment; a second
+consumer reading that record would have had to know whose demo it was.
+
+### The anchor, and what its absence means for a consumer
+
+`anchor_lat_deg`, `anchor_lon_deg` and `anchor_height_m` say where the robot's
+frame sits on the earth. Set all three and the node publishes a
+`FrameTransform` from that frame to `earth-fixed`. Set none and it publishes
+none — a supported mode, not a misconfiguration. Set one or two and it refuses
+to start, because a partial anchor is not a weaker claim about where the frame
+is, it is an unusable one.
+
+**What a reader of the scene sees in that mode.** The robot's entity and its
+poses are present, complete and moving, and *this adapter* makes no claim
+about where that frame sits on the earth.
+
+Whether anybody else does is not something it can see. **A venue publishing
+its own georeference is the ordinary case**, and then anchorless is the
+correct configuration — the scene keeps the single claim and the robot does
+not contradict it. That is how SpatialDDS-demo runs. If nobody publishes one,
+a client that wants to place the robot on a globe cannot, and should say so
+rather than assume a position.
+
+The note said "nothing earth-references them" until 2026-10-19, which assumed
+this adapter was the only thing that could. In the first real deployment it
+was not, and anchorless was correct *because* somebody else owned the claim —
+the opposite of the absence the wording described.
+
+The degradation is deliberate either way. The alternative, defaulting the
+anchor to the frame origin, would have every unconfigured robot claiming to be
+in the Gulf of Guinea with a pose that looks entirely plausible. A default is
+not neutral when the thing being defaulted is a claim.
+
+## What it claims, and what it will not
+
+The adapter publishes `basis = OBSERVED` and offers no parameter to change it:
+a self-localizing robot is reporting where it has worked out that it is, which
+is a sighting rather than an assertion. It claims no extent — a robot locates
+itself, it does not legislate a region, and an extent would be read as
+keep-out by anything applying the `DECLARED` rule.
+
+Three things it refuses to do quietly:
+
+- **It does not dispose its entity when the feed goes quiet.** Disposal says
+  the robot is gone; silence only licenses "this is where it was last seen,
+  not where it is". The record is republished `UNOBSERVED` with a reason and
+  the last pose kept.
+- **It does not accept a goal nothing will act on.** No pose publishing, or
+  nav2 not accepting goals, is declined *with the reason* — a declined goal
+  must not look like an ignored one.
+- **It does not let an accepted goal fail silently.** Whether a goal is
+  drivable can depend on where the robot is when it meets a boundary, so the
+  refusal arrives after the acceptance, on the latched record, and stays there
+  until a new goal is accepted.
+
+QoS and topic names are not configurable. Both are interop contracts whose
+failure mode is silence: a mismatched QoS means endpoints that never meet with
+nothing reporting it, and a hand-written topic name means a robot publishing
+where nobody is listening.
+
+### Sharing a participant with another SpatialDDS library
+
+The §3.3.3 profiles go on the **endpoints**. The `Topic` objects this library
+creates carry default QoS, and that is deliberate rather than an omission.
+
+A topic name is unique within a participant, and its QoS has to agree among
+every live `Topic` object for that name — in either direction, with the
+refusal (`DDS_RETCODE_INCONSISTENT_POLICY`) landing on whichever call came
+second. Putting the profile on the topic therefore made topic QoS a contract
+every *other* participant in the process had to match, and nothing in this
+API said so. Version 0.2.0 did that, and SpatialDDS-demo was refused an entity
+reader on a lane this adapter had already opened — both conventions legal DDS,
+neither legal beside the other.
+
+So this library now asks for the least it can: the default, which is what any
+participant that passes no QoS gets, including every ROS and DDS example.
+Nothing leaves the wire — matching is a reader/writer negotiation over
+endpoint QoS, and a topic's QoS enters it only as a default for endpoints that
+ask for one, which these never do.
+
+If you run another SpatialDDS stack in the same process and it creates its
+topics with an explicit QoS, it is the one imposing the contract, and the two
+cannot share that name. `test/test_transport.py::TwoConventionsOnOneTopic`
+pins all of it, including a library writer exchanging real samples with a
+reader built the other convention's way.
+
+### Reads see the lifecycle
+
+`transport.take_samples` returns payloads; `transport.take_with_state` returns
+them alongside instance state for a caller that wants the lifecycle. Both
+matter because CycloneDDS's `take()` does not return payloads only — it also
+yields `InvalidSample` notifications for a dispose or a departed writer, and a
+read that assumes otherwise raises on the first peer that joins a lane and
+leaves. Until 0.2.1 this library made that assumption in one place, which
+reached two call sites, and the first real deployment found it within a
+minute. [`docs/failability.md`](https://github.com/OpenArCloud/spatialdds-ros/blob/main/docs/failability.md) §3 has the tracebacks.
+
+This adapter still does not *act* on disposal: it owns one key, never disposes
+it, and reports going quiet as `UNOBSERVED` — a weaker statement than "this
+robot is gone". Not acting on an event is not the same as not receiving one.
+
+## Tests
+
+```sh
+python3 -m pytest test/ -q
+```
+
+Everything runs with no ROS installed — that is a gate
+(`test/test_no_ros_needed.py`), not a habit, since one module-scope
+`import rclpy` would take the whole suite offline. The DDS-backed tests need
+`cyclonedds` and skip with a reason without it.
+
+| document | what is in it |
+|---|---|
+| [`docs/extraction-census.md`](https://github.com/OpenArCloud/spatialdds-ros/blob/main/docs/extraction-census.md) | what became a parameter, what the library fills, and why |
+| [`docs/failability.md`](https://github.com/OpenArCloud/spatialdds-ros/blob/main/docs/failability.md) | the two claims broken deliberately, with the failures |
+| [`docs/spec-queue.md`](https://github.com/OpenArCloud/spatialdds-ros/blob/main/docs/spec-queue.md) | two things for the specification rather than worked around |
+| [`spatialdds_idl18/PROVENANCE.md`](https://github.com/OpenArCloud/spatialdds-ros/blob/main/spatialdds_idl18/PROVENANCE.md) | where the vendored 1.8 bindings came from |
+| [`docs/RELEASING.md`](https://github.com/OpenArCloud/spatialdds-ros/blob/main/docs/RELEASING.md) | how a version reaches PyPI, and how the artifact is checked against the commit |
+
+## Licence
+
+MIT. See [`LICENSE`](https://github.com/OpenArCloud/spatialdds-ros/blob/main/LICENSE).

spatialdds_ros-0.3.0.dist-info/RECORD

@@ -0,0 +1,87 @@
+spatialdds_idl18/PROVENANCE.md,sha256=67ABiglFknhMc2420c5re6w9Mk0jzy7fIroCFwD3Fy0,3120
+spatialdds_idl18/__init__.py,sha256=rfl2cis6sDbulhllvI21ttr67V6nZs2wN9LAwM0MLn8,345
+spatialdds_idl18/_field_aliases.py,sha256=0O5N-Nm5PUPOvbmvjLHfHhCbepUnlKAzTKQ-gvBF4b4,801
+spatialdds_idl18/builtin/__init__.py,sha256=FjNPEwEu1CAfEA1GQYtfVImm-kpCkEtkjqw7xz4wO08,166
+spatialdds_idl18/builtin/_types.py,sha256=qfCX7JvoMmOqGQMfdAqntR8sNIcxwj6ph9Hpw1Skriw,597
+spatialdds_idl18/spatial/__init__.py,sha256=tpmCAmyg6HNzlzidV5TipJYF4HmtPg5smw0CyjrGoLU,522
+spatialdds_idl18/spatial/anchors/__init__.py,sha256=gMH2qBzXZuPNnw_CPtps_f3OKYQ2gIabE8P35IKmb_w,431
+spatialdds_idl18/spatial/anchors/_anchors.py,sha256=x9rTD5kJJnAKSXGd5P6lGAVDszfJWZOeAbCsvY2Z2yU,2972
+spatialdds_idl18/spatial/argeo/__init__.py,sha256=zJeYNlCn6Uhoj5cc1fXyaUHVqUlz0ETWykPf3WJxCf0,461
+spatialdds_idl18/spatial/argeo/_argeo.py,sha256=S7OsTy6dm-gICrK1f17iY84R7xzCkHDTQM8NHHUsyhA,3214
+spatialdds_idl18/spatial/common/__init__.py,sha256=IJqLXqKKp90TytZCDlyKHpWVdS-SaehJn3FoUqsxbPc,549
+spatialdds_idl18/spatial/common/_types.py,sha256=wQYCdNuMTm433yvTBcsT8TJOz5_0hRccai0jZRbBbhM,3278
+spatialdds_idl18/spatial/core/__init__.py,sha256=OYdv4aLYoYWxMdto29DH7f3XE3t90cUHDq4hhwcFmQI,933
+spatialdds_idl18/spatial/core/_core.py,sha256=jxja36n3SP-HvU5I2XOHOS0oT2k654NgTPNJrixIoSc,10051
+spatialdds_idl18/spatial/core/GnssService/__init__.py,sha256=u9p9cIOXpkfYdJJD9gGhRE731oJAiqudEtR_o9x0kMI,294
+spatialdds_idl18/spatial/core/GnssService/_core.py,sha256=anv8eF4fkB4oLibGj6Z-AH9Gprsfd8RSw3S2WxocDu4,526
+spatialdds_idl18/spatial/disco/__init__.py,sha256=7j0NiaNprvOkNRJ0WinG_LULhVDNh2kjrTIO1ZkT5tw,811
+spatialdds_idl18/spatial/disco/_discovery.py,sha256=czy9pO7C0DHOvBoFDMXFd8CSrsN_0CrSiHcGB19VsEc,8399
+spatialdds_idl18/spatial/events/__init__.py,sha256=sMoXRjGPsChKZMzP3-M24EQYa5MIqK061KwOxa222RA,606
+spatialdds_idl18/spatial/events/_events.py,sha256=Vzo-8dHxiGTgYOvW896oSkup-QFgn3blrbsKamLlWT4,6244
+spatialdds_idl18/spatial/events/enums/__init__.py,sha256=gKCTnBEMrei7IW9c43yh00mejNg0HpPq1HVmvyXliPw,407
+spatialdds_idl18/spatial/events/enums/crossing_direction_enum/__init__.py,sha256=LLyuCy7U3XgBE7ERkms9CvahNxd6J_b7hKGvkC03krU,230
+spatialdds_idl18/spatial/events/enums/crossing_direction_enum/_events.py,sha256=dT3Q_6VplUYVBKRBjB12s4zhxF4ZExhmCluMK2zOvsQ,697
+spatialdds_idl18/spatial/events/enums/event_state_enum/__init__.py,sha256=-SN9-B3xJlumTt-LUW_aAVge9_WdIh28FkZJXHc_gIM,209
+spatialdds_idl18/spatial/events/enums/event_state_enum/_events.py,sha256=qACxsDdGvUdM2M9_T3EjlGaxLwysNWoFaBrIF4odNmg,662
+spatialdds_idl18/spatial/events/enums/event_type_enum/__init__.py,sha256=qFkOUmiw_3LX0m-cyHxy98_IJzTCd8N-sz5V7Ku616o,206
+spatialdds_idl18/spatial/events/enums/event_type_enum/_events.py,sha256=Q8AhyDJTlzaVN7GC83CIzgP_5hZzjjmFDRgC0wtBjMk,875
+spatialdds_idl18/spatial/events/enums/severity_enum/__init__.py,sha256=b91jFRWGQvNCxT2RFYUh50qbHTpretq71KMoQwP6Zws,202
+spatialdds_idl18/spatial/events/enums/severity_enum/_events.py,sha256=IT8MrlrMEIx0YmqH3vn5Iz1rYU2SZV_XgCZRFUrA_uI,638
+spatialdds_idl18/spatial/events/enums/zone_kind_enum/__init__.py,sha256=CFglMhgHRw8vRwSSREH6MCc8qsOSBl9OltWcfaElu78,203
+spatialdds_idl18/spatial/events/enums/zone_kind_enum/_events.py,sha256=QKYO3oySpoaxQC_5_B6sZWI0UOC2AacRHFqPlMK5cYg,749
+spatialdds_idl18/spatial/mapping/__init__.py,sha256=ehXVRIi9mwGG3puvkvV-Oh8JelQ1ZcK5qWscgWUre6I,615
+spatialdds_idl18/spatial/mapping/_mapping.py,sha256=ErJvTQ0MEdLDL7Fo91-hJ2CEQYtaOW6WrBBEpQZ4fS0,6065
+spatialdds_idl18/spatial/mapping/enums/__init__.py,sha256=3d4icZMbGZsD8x1NlcKaqhdAcdJVI9Co-5rRsCOT40o,360
+spatialdds_idl18/spatial/mapping/enums/alignment_method/__init__.py,sha256=U6X5WUL-by1gklTk6Csqy-pnQjrOeL-POc8HmumbnLg,221
+spatialdds_idl18/spatial/mapping/enums/alignment_method/_mapping.py,sha256=HHDtUREYp_vVHunsehnMeKTtFDUmoyqq7oiqhTTTVIA,780
+spatialdds_idl18/spatial/mapping/enums/edge_type/__init__.py,sha256=6AHJl56olb6zpQ-cJLe75sbSkPqPd7ibWdOGEHGNugo,200
+spatialdds_idl18/spatial/mapping/enums/edge_type/_mapping.py,sha256=Xr1SjRO6l_zLEA0MmkzNa77CNCj_G02iCqvX6vIFgvg,755
+spatialdds_idl18/spatial/mapping/enums/map_event_kind/__init__.py,sha256=7TGaQ89E72vw1DiPZjlAvfWO1s7g82jgTfDaecXH76k,213
+spatialdds_idl18/spatial/mapping/enums/map_event_kind/_mapping.py,sha256=8KTd1j5HUfMF2yEoojpkDBDeRUjNQLQXda7uCCZTNyg,736
+spatialdds_idl18/spatial/mapping/enums/map_kind/__init__.py,sha256=KMdWg8BuUHCq4PzYRUHW1lGbDULnFAOhkrmRniKc6d0,197
+spatialdds_idl18/spatial/mapping/enums/map_kind/_mapping.py,sha256=UZ8SMFOAFRU8lG_rk3mlaga1mFnmZsM84s2ciKiDBIo,749
+spatialdds_idl18/spatial/mapping/enums/map_status/__init__.py,sha256=ap8tCIXZHTba1q2MVfmwIrlX83WJNrWrzhqQJ885X_M,203
+spatialdds_idl18/spatial/mapping/enums/map_status/_mapping.py,sha256=a4Ap4za3raiURz901Ir0HbSUACeOl2x1eRLCTsbI3vY,666
+spatialdds_idl18/spatial/owm/__init__.py,sha256=ZmtBwjuaxr4hSsPo6UZhEhnMRxe2lamkPq0W3aH57J0,419
+spatialdds_idl18/spatial/owm/_owm.py,sha256=hOuwQok5jrt5KwSZIUdBygaRyaO0KaEXf3o3y_emQpM,3234
+spatialdds_idl18/spatial/semantics/__init__.py,sha256=dX70aCF7eEyKcrt51sjlClzwBpSU3BeOkMJZG3poAAA,495
+spatialdds_idl18/spatial/semantics/_semantics.py,sha256=MvQf4NF8od5er9_dasgjQxxy7sOavG5mY-MLPRMnWVA,5632
+spatialdds_idl18/spatial/sensing/__init__.py,sha256=0u6NAEhJ-gKliI1d_w-8NkDyvXEsfH4sRsBjkxn5Www,324
+spatialdds_idl18/spatial/sensing/common/__init__.py,sha256=ckiFGF0A5t1MUdBNr1Fb1wdF-_DBYkNj2005QLgeYXw,715
+spatialdds_idl18/spatial/sensing/common/_common.py,sha256=PGhRim6RJqRueWppvqGEvw8pxpAyL5DEXqQyTcmn7iU,5822
+spatialdds_idl18/spatial/sensing/lidar/__init__.py,sha256=yaXo7sOpYoWJwuoZdN93yzpYMlE1IbP3xcwUNHfOPM0,723
+spatialdds_idl18/spatial/sensing/lidar/_lidar.py,sha256=RRg6tgZQ5aORnmPiVIqplz3wlRBKZP4q9n3GgZG21ss,5443
+spatialdds_idl18/spatial/sensing/rad/__init__.py,sha256=kyPygAAuRk2LXNZTFJvldRs1viBz-Rdk_GPA_JgtLEg,770
+spatialdds_idl18/spatial/sensing/rad/_rad.py,sha256=o5vMMvzoQYgCqrOyd5VrvkIxewDqTo4ifNLN12uzIf4,7251
+spatialdds_idl18/spatial/sensing/radio/__init__.py,sha256=DgT6t8m1bNTkqraZEWykmvvH4zvkq9uG8u355vBE2bA,491
+spatialdds_idl18/spatial/sensing/radio/_radio.py,sha256=fPcT4gVwozFPIkDcah5RLgbQFiOvRkS3VhmRL5wEyY4,4526
+spatialdds_idl18/spatial/sensing/rf_beam/__init__.py,sha256=rWSB35LKhsRP0SuJuRlZMBBKKFgH-TmQE-g_UdpqdZ4,554
+spatialdds_idl18/spatial/sensing/rf_beam/_rf_beam.py,sha256=p-_CqixMWJvFzKtP_UT_A4cBBJMGT8rmtmRTJC-mw1s,4307
+spatialdds_idl18/spatial/sensing/vision/__init__.py,sha256=SU_FtKZbQY_8DATrIenMAmWb085t6X7aRKddgDagePw,809
+spatialdds_idl18/spatial/sensing/vision/_vision.py,sha256=6Zkmwi2iA661IdoHQxrIzQJFRv2CSFZKqUVtUWH62YA,6396
+spatialdds_idl18/spatial/slam_frontend/__init__.py,sha256=mOaidTGrjOcf5vy52X_s3gsqKli8UdECKegk6Av1fwY,495
+spatialdds_idl18/spatial/slam_frontend/_slam_frontend.py,sha256=CR3uLamKCDNirk3FypB3mmRRKJw3a1vCuo5t-ZBpddk,4115
+spatialdds_idl18/spatial/vio/__init__.py,sha256=sjPzFWP42rzkeJB9L89vu4K41U3tjCY6nxwRXTg-0SQ,441
+spatialdds_idl18/spatial/vio/_vio.py,sha256=OKjV_J4aepdaHQ-9qTH2W62iyU5XjEv2EBFUeW3OnP0,4148
+spatialdds_ros/__init__.py,sha256=T6dmOFukGKDGFGW-tpaf2aGM7qhrq8bf-6nzhFKbfvs,138
+spatialdds_ros/adapter.py,sha256=Zc_bX_tEKxq86JAG6izI2ScUbI9x72MpSwqd47zGnCI,15271
+spatialdds_ros/announce.py,sha256=KiaU1yTWkb9VQi4MFG4zLEeCcyyqZSa4jFtBE7oB0gs,10607
+spatialdds_ros/config.py,sha256=bMF6CJqm391HKpwdnSSx3K84DKCJ9iozyVkcKizG7vg,13385
+spatialdds_ros/frames.py,sha256=gj8y6d7q9kL76HqKeWbMrKnKlyH0tm9dxOLBpBdnLyQ,8428
+spatialdds_ros/kinematic.py,sha256=cUonIQP6Esuifkhgw8t1cCDOabcjxMIfwojq9V331eo,5905
+spatialdds_ros/qos.py,sha256=y2XYmElnjHO4vfUlaapXOK1K8DHZZD44xn2jNG_PQ-0,4673
+spatialdds_ros/recording.py,sha256=CKS6wjv-lulnMGAjqFA0uWLc-4blMHo3FOADj7jbmFU,7135
+spatialdds_ros/robot_node.py,sha256=kgWXg-akb3cP26bSszq618CJrUmOxuZJNr_NRgzj_8M,12204
+spatialdds_ros/standalone.py,sha256=N2gaEjRcSz6t8nwAeI-Y0wArl6y19K7R95LOUznxs7Q,9073
+spatialdds_ros/tempo.py,sha256=kiIfrHhXaTWYxAxkjakE4LHAui4rt8szihD2SvTr734,4500
+spatialdds_ros/topics.py,sha256=S0g9QKnt7uI_Wepa-_MqvHbLspqNhn9TuwOit2kheb4,2314
+spatialdds_ros/transport.py,sha256=l_WXiEQWbFEHlViMPF5SWIVwZJ_BB8MzrE0vwkMzOWY,7600
+spatialdds_ros-0.3.0.data/data/share/ament_index/resource_index/packages/spatialdds_ros,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spatialdds_ros-0.3.0.data/data/share/spatialdds_ros/package.xml,sha256=2M48WVIZbJjMHJ2KQKRiwmrP2dVvwfNGCiKmseFiE5Y,1043
+spatialdds_ros-0.3.0.dist-info/licenses/LICENSE,sha256=4rWO0Ng52-5yK5ns3A0M5Y1ZbOtFkBuFuzXxHwHSa0w,1070
+spatialdds_ros-0.3.0.dist-info/METADATA,sha256=_l3wgrTwCbJRj3YKqjBF3UR-nizTNRjQaJ50yfeQFc0,15301
+spatialdds_ros-0.3.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+spatialdds_ros-0.3.0.dist-info/entry_points.txt,sha256=HAaYrvo_oFbdb2zud59LJA_ENEhBgAi7jrj_Au8udlI,110
+spatialdds_ros-0.3.0.dist-info/top_level.txt,sha256=2t0qZAbyjcevZW6h2wnwh6VRjc5TzIeURXsL9EbcaT4,32
+spatialdds_ros-0.3.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+spatialdds_ros-0.3.0.dist-info/RECORD,,

spatialdds_ros-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

spatialdds_ros-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+kinematic_node = spatialdds_ros.standalone:main
+robot_node = spatialdds_ros.robot_node:main

spatialdds_ros-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Open AR Cloud
+
+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.

spatialdds_ros-0.3.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+spatialdds_idl18
+spatialdds_ros

spatialdds_ros-0.3.0.dist-info/zip-safe

@@ -0,0 +1 @@
+