Add Support for Publishing, More Types, and Basic QoS

pyopendds/DataReader.py

@@ -3,27 +3,48 @@
 from .Topic import Topic
 from .constants import StatusKind
 from .util import TimeDurationType, normalize_time_duration
+from .Qos import DataReaderQos
+
+from typing import TYPE_CHECKING, Callable, Optional, Any
 
-from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from .Subscriber import Subscriber
 
 
 class DataReader:
 
-    def __init__(self, subscriber: Subscriber, topic: Topic, qos=None, listener=None):
+    def __init__(self, subscriber: Subscriber, topic: Topic, qos=DataReaderQos(), listener: Optional[Callable[..., None]] = None):
         self.topic = topic
-        self.qos = qos
         self.listener = listener
         self.subscriber = subscriber
+        self.qos = qos
         subscriber.readers.append(self)
 
-        from _pyopendds import create_datareader
-        create_datareader(self, subscriber, topic)
-
-    def wait_for(self, status: StatusKind, timeout: TimeDurationType):
-        from _pyopendds import datareader_wait_for
-        return datareader_wait_for(self, status, *normalize_time_duration(timeout))
-
-    def take_next_sample(self):
-        return self.topic._ts_package.take_next_sample(self)
+        from _pyopendds import create_datareader  # noqa
+        #verify if callback is None 
+        if self.listener == None :
+            create_datareader(self, subscriber, topic, None, self.qos)
+        else : 
+            create_datareader(self, subscriber, topic, self.on_data_available_callback, self.qos)
+
+
+    def wait_for(self, timeout: TimeDurationType, status: StatusKind = StatusKind.SUBSCRIPTION_MATCHED):
+        from _pyopendds import datareader_wait_for  # noqa
+        datareader_wait_for(self, status, *normalize_time_duration(timeout))
+
+    def take_next_sample(self) -> Any:
+        return self.topic.ts_package.take_next_sample(self)
+
+    def on_data_available_callback(self):
+        sample = self.take_next_sample()
+        topicname = self.topic.name
+        print("on data available callback")
+
+        if sample is None:
+            # print("on_data_available_callback error: sample is None")
+            pass
+        elif self.listener is not None:
+            try: # if callback have 2 arguments
+                self.listener(sample,topicname)
+            except  : # if callback have 1 arguments
+                self.listener(sample)

pyopendds/DataWriter.py

@@ -1,2 +1,32 @@
+from __future__ import annotations
+
+from .Topic import Topic
+from .constants import StatusKind
+from .util import TimeDurationType, normalize_time_duration
+from .Qos import DataWriterQos
+
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from .Publisher import Publisher
+
+
 class DataWriter:
-    pass
+
+    def __init__(self, publisher: Publisher, topic: Topic, qos=DataWriterQos()):
+        self.topic = topic
+        self.publisher = publisher
+        self.qos = qos
+        publisher.writers.append(self)
+
+        from _pyopendds import create_datawriter  # noqa
+        create_datawriter(self, publisher, topic,self.qos)
+
+
+    def wait_for(self, timeout: TimeDurationType, status: StatusKind = StatusKind.PUBLICATION_MATCHED):
+        from _pyopendds import datawriter_wait_for  # noqa
+        datawriter_wait_for(self, status, *normalize_time_duration(timeout))
+
+    def write(self, sample) -> int:
+        return self.topic.ts_package.write(self, sample)

pyopendds/DomainParticipant.py

@@ -2,8 +2,15 @@
 from .Subscriber import Subscriber
 from .Publisher import Publisher
 
+try:
+    from _pyopendds import participant_cleanup  # noqa
+except ImportError as e:
+    def participant_cleanup(*args):
+        pass
+    pass
 
-class DomainParticipant:
+
+class DomainParticipant(object):
 
     def __init__(self, domain: int, qos=None, listener=None):
         self.domain = int(domain)
@@ -14,19 +21,17 @@ def __init__(self, domain: int, qos=None, listener=None):
         self.publishers = []
         self._registered_typesupport = []
 
-        from _pyopendds import create_participant
+        from _pyopendds import create_participant  # noqa
         create_participant(self, domain)
 
     def __del__(self):
-        from _pyopendds import participant_cleanup
         participant_cleanup(self)
 
-    def create_topic(self,
-            name: str, topic_type: type, qos=None, listener=None) -> Topic:
+    def create_topic(self, name: str, topic_type: type, qos=None, listener=None) -> Topic:
         return Topic(self, name, topic_type, qos, listener)
 
     def create_subscriber(self, qos=None, listener=None) -> Subscriber:
         return Subscriber(self, qos, listener)
 
-    def create_publisher(self, qos=None, listener=None) -> Publisher:
-        return Publisher(self, qos, listener)
+    def create_publisher(self, qos=None) -> Publisher:
+        return Publisher(self, qos)

pyopendds/Publisher.py

@@ -1,22 +1,23 @@
 from __future__ import annotations
 
+from .DataWriter import DataWriter
 from .Topic import Topic
 
 from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from .DomainParticipant import DomainParticipant
 
 
-class Publisher:
+class Publisher(object):
 
-    def __init__(self, participant: DomainParticipant, qos=None, listener=None):
+    def __init__(self, participant: DomainParticipant, qos=None):
         participant.publishers.append(self)
         self.qos = qos
-        self.listener = listener
         self.writers = []
-
-        from _pyopendds import create_publisher
+        from _pyopendds import create_publisher  # noqa
         create_publisher(self, participant)
 
-    def create_datawriter(self, topic: Topic, qos=None, listener=None):
-        pass
+    def create_datawriter(self, topic: Topic, qos=None) -> DataWriter:
+        writer = DataWriter(self, topic, qos)
+        self.writers.append(writer)
+        return writer

pyopendds/Qos.py

@@ -0,0 +1,49 @@
+from enum import IntEnum
+
+
+class DurabilityQosPolicyKind(IntEnum):
+    VOLATILE_DURABILITY_QOS = 0,
+    TRANSIENT_LOCAL_DURABILITY_QOS = 1,
+    TRANSIENT_DURABILITY_QOS = 2,
+    PERSISTENT_DURABILITY_QOS = 3
+
+
+class ReliabilityQosPolicyKind(IntEnum):
+    BEST_EFFORT_RELIABILITY_QOS = 0,
+    RELIABLE_RELIABILITY_QOS = 1
+
+
+class HistoryQosPolicyKind(IntEnum):
+    KEEP_LAST_HISTORY_QOS = 0,
+    KEEP_ALL_HISTORY_QOS = 1
+
+
+class DurabilityQosPolicy:
+    def __init__(self):
+        self.kind = DurabilityQosPolicyKind.VOLATILE_DURABILITY_QOS
+
+
+class ReliabilityQosPolicy:
+    def __init__(self):
+        self.kind = ReliabilityQosPolicyKind.BEST_EFFORT_RELIABILITY_QOS
+        self.max_blocking_time = 0
+
+
+class HistoryQosPolicy:
+    def __init__(self):
+        self.kind = HistoryQosPolicyKind.KEEP_LAST_HISTORY_QOS
+        self.depth = 1
+
+
+class DataWriterQos:
+    def __init__(self):
+        self.durability = DurabilityQosPolicy()
+        self.reliability = ReliabilityQosPolicy()
+        self.history = HistoryQosPolicy()
+
+
+class DataReaderQos:
+    def __init__(self):
+        self.durability = DurabilityQosPolicy()
+        self.reliability = ReliabilityQosPolicy()
+        self.history = HistoryQosPolicy()

pyopendds/Subscriber.py

@@ -15,9 +15,10 @@ def __init__(self, participant: DomainParticipant, qos=None, listener=None):
         self.qos = qos
         self.listener = listener
         self.readers = []
-
-        from _pyopendds import create_subscriber
+        from _pyopendds import create_subscriber  # noqa
         create_subscriber(self, participant)
 
-    def create_datareader(self, topic: Topic, qos=None, listener=None):
-        return DataReader(self, topic, qos, listener)
+    def create_datareader(self, topic: Topic, qos=None, listener=None) -> DataReader:
+        reader = DataReader(self, topic, qos, listener)
+        self.readers.append(reader)
+        return reader

pyopendds/Topic.py

@@ -7,9 +7,7 @@
 
 class Topic:
 
-    def __init__(self,
-            participant: DomainParticipant, name: str, topic_type: type,
-            qos=None, listener=None):
+    def __init__(self, participant: DomainParticipant, name: str, topic_type: type, qos=None, listener=None):
         participant.topics[name] = self
         self.name = name
         self.type = topic_type
@@ -18,12 +16,14 @@ def __init__(self,
 
         # Get OpenDDS Topic Type Name
         import importlib
-        self._ts_package = \
-            importlib.import_module(
-                topic_type._pyopendds_typesupport_packge_name)
-        if topic_type not in participant._registered_typesupport:
-            self._ts_package.register_type(participant, topic_type)
-        self.type_name = self._ts_package.type_name(topic_type)
+        self._ts_package = importlib.import_module(topic_type._pyopendds_typesupport_packge_name)  # noqa
+        if topic_type not in participant._registered_typesupport:    # noqa
+            self._ts_package.register_type(participant, topic_type)  # noqa
 
-        from _pyopendds import create_topic
+        self.type_name = self._ts_package.type_name(topic_type)      # noqa
+        from _pyopendds import create_topic                          # noqa
         create_topic(self, participant, name, self.type_name)
+
+    @property
+    def ts_package(self):
+        return self._ts_package