From 55966c44a2bef6a0c7f985287b138cd336ce3019 Mon Sep 17 00:00:00 2001
From: abawi <fares.abawi@uni-hamburg.de>
Date: Thu, 18 Aug 2022 00:04:49 +0200
Subject: [PATCH 1/6] vid_warhole example is still broken

---
 examples/vid_warhol.py | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)

diff --git a/examples/vid_warhol.py b/examples/vid_warhol.py
index 23c2863..bc8a7aa 100644
--- a/examples/vid_warhol.py
+++ b/examples/vid_warhol.py
@@ -5,7 +5,7 @@
 import cv2
 
 from wrapify.connect.wrapper import MiddlewareCommunicator
-from wrapify.config.manager import ConfigManager
+# from wrapify.config.manager import ConfigManager
 
 """
 Warhol effect on captures from camera
@@ -94,7 +94,10 @@ def cv2_to_pil(img):
         if isinstance(img, Image.Image):
             return img
         else:
-            return Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+            try:
+                return Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+            except:
+                return img
 
     @staticmethod
     def pil_to_cv2(img):
@@ -103,7 +106,7 @@ def pil_to_cv2(img):
         else:
             return img
 
-    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/darken_bg", carrier="tcp", width="$img_width", height="$img_height", rgb=True)
+    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/darken_bg", carrier="mcast", width="$img_width", height="$img_height", rgb=True, should_wait=True)
     def darken_bg(self, img, color, img_width, img_height):
         img = self.cv2_to_pil(img)
         # composite image on top of a single-color image, effectively turning all transparent parts to that color
@@ -112,7 +115,7 @@ def darken_bg(self, img, color, img_width, img_height):
         masked_img = self.pil_to_cv2(masked_img)
         return masked_img,
 
-    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/color_bg_fg", carrier="tcp", width="$img_width", height="$img_height", rgb=True)
+    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/color_bg_fg", carrier="mcast", width="$img_width", height="$img_height", rgb=True, should_wait=True)
     def color_bg_fg(self, img, bg_color, fg_color, img_width, img_height):
         img = self.cv2_to_pil(img)
         # change transparent background to bg_color and change everything non-transparent to fg_color
@@ -122,7 +125,7 @@ def color_bg_fg(self, img, bg_color, fg_color, img_width, img_height):
         masked_img = self.pil_to_cv2(masked_img)
         return masked_img,
 
-    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/white_to_color", carrier="tcp", width="$img_width", height="$img_height", rgb=True)
+    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/white_to_color", carrier="mcast", width="$img_width", height="$img_height", rgb=True, should_wait=True)
     def white_to_color(self, img, color, img_width, img_height):
         img = self.cv2_to_pil(img).convert('RGBA')
         # change all colors close to white and non-transparent (alpha > 0) to be color
@@ -146,18 +149,22 @@ def white_to_color(self, img, color, img_width, img_height):
     def make_warhol_single(self, img, bg_color, fg_color, skin_color):
         # create a single warhol-serigraph-style image
         bg_fg_layer, = self.color_bg_fg(img, bg_color, fg_color, img_width=img.size[0], img_height=img.size[1])
-        bg_fg_layer = self.cv2_to_pil(bg_fg_layer).convert('RGBA')
+        if bg_fg_layer is not None:
+            bg_fg_layer = self.cv2_to_pil(bg_fg_layer).convert('RGBA')
         temp_dark_image, = self.darken_bg(img, (0, 0, 0, 255), img_width=img.size[0], img_height=img.size[1])
-        temp_dark_image = self.cv2_to_pil(temp_dark_image).convert('RGBA')
-        skin_mask, = self.white_to_color(temp_dark_image, (0, 0, 0, 0), img_width=temp_dark_image.size[0], img_height=temp_dark_image.size[1])
-        skin_mask = self.cv2_to_pil(skin_mask).convert('RGBA')
+        skin_mask = None
+        if temp_dark_image is not None:
+            temp_dark_image = self.cv2_to_pil(temp_dark_image).convert('RGBA')
+            skin_mask, = self.white_to_color(temp_dark_image, (0, 0, 0, 0), img_width=temp_dark_image.size[0], img_height=temp_dark_image.size[1])
+        if skin_mask is not None:
+            skin_mask = self.cv2_to_pil(skin_mask).convert('RGBA')
 
         skin_layer = Image.new('RGBA', img.size, skin_color)
         out = Image.composite(bg_fg_layer, skin_layer, skin_mask)
         return out
 
-    @MiddlewareCommunicator.register([["Image", "yarp", "Warholify", "/vid_warhol/warhol_" + str(x), {"carrier": "tcp", "width": "$img_width", "height": "$img_height"}] for x in range(9)])
-    @MiddlewareCommunicator.register("Image", "Warholify", "/vid_warhol/warhol_combined", carrier="tcp", width="$img_width", height="$img_height")
+    @MiddlewareCommunicator.register([["Image", "yarp", "Warholify", "/vid_warhol/warhol_" + str(x), {"carrier": "mcast", "width": "$img_width", "height": "$img_height", "should_wait": True}] for x in range(9)])
+    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/warhol_combined", carrier="mcast", width="$img_width", height="$img_height", should_wait=True)
     def combine_to_one(self, warhols, img_width, img_height):
         warhols_new = []
         for warhol in warhols:
@@ -195,7 +202,7 @@ def warholify_images(self, img):
 
         return blank_img
 
-    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/feed", carrier="tcp", width="$img_width", height="$img_height")
+    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/feed", carrier="mcast", width="$img_width", height="$img_height", should_wait=True)
     def capture_vid(self, img_width, img_height):
         if self.vid_cap is None:
             self.vid_cap = cv2.VideoCapture(self.vid_src)
@@ -215,7 +222,7 @@ def transform(self, img_width=640, img_height=480):
             return img
 
 
-    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/final_img", carrier="tcp", width="$img_width", height="$img_height", rgb=True)
+    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/final_img", carrier="mcast", width="$img_width", height="$img_height", rgb=True, should_wait=True)
     def display(self, img, img_width, img_height):
         cv2.imshow("Warhol", img)
         cv2.waitKey(1)
@@ -246,6 +253,6 @@ def parse_args():
 if __name__ == "__main__":
     args = parse_args()
     print(args.cfg_file)
-    ConfigManager(args.cfg_file)
+    # ConfigManager(args.cfg_file)
     warholify = Warholify(vid_src=args.vid_src, img_width=args.img_width, img_height=args.img_height)
     warholify.run()
\ No newline at end of file

From ca0ae8c171855f36a11d61dc82fdba3180000fda Mon Sep 17 00:00:00 2001
From: abawi <fares.abawi@uni-hamburg.de>
Date: Thu, 18 Aug 2022 00:05:39 +0200
Subject: [PATCH 2/6] Re-oder wrapper condition to avoid instance enumeration
 when mode is None

---
 wrapify/connect/wrapper.py | 32 +++++++++++++++++---------------
 1 file changed, 17 insertions(+), 15 deletions(-)

diff --git a/wrapify/connect/wrapper.py b/wrapify/connect/wrapper.py
index 46acc09..8121588 100644
--- a/wrapify/connect/wrapper.py
+++ b/wrapify/connect/wrapper.py
@@ -19,7 +19,7 @@ def __init__(self):
                 self.activate_communication(getattr(self.__class__, key), mode=value)
 
     @classmethod
-    def register(cls, data_type, middleware, *args, **kwargs):
+    def register(cls, data_type, middleware=DEFAULT_COMMUNICATOR, *args, **kwargs):
         def encapsulate(func):
             # define the communication message type (single element)
             if isinstance(data_type, str):
@@ -66,25 +66,26 @@ def encapsulate(func):
 
             @wraps(func)
             def wrapper(*wds, **kwds):  # Triggers on calling the function
-
-                instance_address = hex(id(wds[0]))
-                instance_id = cls._MiddlewareCommunicator__registry[func.__qualname__]["__WRAPIFY_INSTANCES"].index(instance_address) + 1
-                instance_id = "." + str(instance_id) if instance_id > 1 else ""
-
-                kwd = get_default_args(func)
-                kwd.update(kwds)
-                cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["args"] = wds
-                cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["kwargs"] = kwd
-
                 # execute the function as usual
-                if cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["mode"] is None:
+                if cls._MiddlewareCommunicator__registry[func.__qualname__]["mode"] is None:
                     return func(*wds, **kwds)
+                else:
+                    instance_address = hex(id(wds[0]))
+                    instance_id = cls._MiddlewareCommunicator__registry[func.__qualname__]["__WRAPIFY_INSTANCES"].index(instance_address) + 1
+                    instance_id = "." + str(instance_id) if instance_id > 1 else ""
+
+                    kwd = get_default_args(func)
+                    kwd.update(kwds)
+                    cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["args"] = wds
+                    cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["kwargs"] = kwd
+
 
                 # publishes the functions returns
-                elif cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["mode"] == "publish":
+                if cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["mode"] == "publish":
                     if "wrapped_executor" not in cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["communicator"][0]:
                         # instantiate the publishers
-                        for communicator in reversed(cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["communicator"]):
+                        cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["communicator"].reverse()
+                        for communicator in cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["communicator"]:
                             # single element
                             if isinstance(communicator["return_func_type"], str):
                                 new_args, new_kwargs = match_args(
@@ -113,7 +114,8 @@ def wrapper(*wds, **kwds):  # Triggers on calling the function
                 elif cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["mode"] == "listen":
                     if "wrapped_executor" not in cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["communicator"][0]:
                         # instantiate the listeners
-                        for communicator in reversed(cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["communicator"]):
+                        cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["communicator"].reverse()
+                        for communicator in cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["communicator"]:
                             # single element
                             if isinstance(communicator["return_func_type"], str):
                                 new_args, new_kwargs = match_args(communicator["return_func_args"], communicator["return_func_kwargs"], wds[1:], kwd)

From 9eb58f02671b4d0c17ef5545a8ee18e2d615524b Mon Sep 17 00:00:00 2001
From: abawi <fares.abawi@uni-hamburg.de>
Date: Thu, 18 Aug 2022 21:12:12 +0200
Subject: [PATCH 3/6] Enabled watchdog scanning for yarp (lstn/publ) and ros
 (publ)

---
 examples/torch_tensor.py      |  16 +++--
 examples/vid_warhol.py        |  30 ++++----
 wrapify/connect/listeners.py  |  28 ++++++--
 wrapify/connect/publishers.py |  33 +++++++--
 wrapify/connect/wrapper.py    |  36 ++++------
 wrapify/listeners/yarp.py     | 128 ++++++++++++++++++++--------------
 wrapify/publishers/ros.py     |  63 ++++++++++++-----
 wrapify/publishers/yarp.py    |  67 +++++++++++++-----
 8 files changed, 258 insertions(+), 143 deletions(-)

diff --git a/examples/torch_tensor.py b/examples/torch_tensor.py
index 7d8f095..c8e65e3 100644
--- a/examples/torch_tensor.py
+++ b/examples/torch_tensor.py
@@ -33,22 +33,26 @@ def parse_args():
     class Notify(MiddlewareCommunicator):
 
         @MiddlewareCommunicator.register("NativeObject", args.mware, "Notify", "/notify/test_native_exchange",
-                                         carrier="", should_wait=True, load_torch_device='cpu')
+                                         carrier="", should_wait=False, load_torch_device='cpu')
+        @MiddlewareCommunicator.register("NativeObject", args.mware, "Notify", "/notify/test_native_exchange2",
+                                         carrier="", should_wait=False, load_torch_device='cpu')
         def exchange_object(self, msg):
             ret = {"message": msg,
                    "torch_ones": torch.ones((2, 4), device='cpu'),
                    "torch_zeros_cuda": torch.zeros((2, 3), device='cuda')}
-            return ret,
+            str_ret = f"this is your message transmitted as a string {msg}"
+            return ret, str_ret
 
     notify = Notify()
 
     if args.mode == "publish":
         notify.activate_communication(Notify.exchange_object, mode="publish")
         while True:
-            msg_object, = notify.exchange_object(input("Type your message: "))
-            print("Method result:", msg_object)
+            msg_object, msg_str = notify.exchange_object(input("Type your message: "))
+            print("Method result:", msg_object, msg_str)
     elif args.mode == "listen":
         notify.activate_communication(Notify.exchange_object, mode="listen")
         while True:
-            msg_object, = notify.exchange_object(None)
-            print("Method result:", msg_object)
+            msg_object, msg_str = notify.exchange_object(None)
+            if msg_object is not None:
+                print("Method result:", msg_object, msg_str)
diff --git a/examples/vid_warhol.py b/examples/vid_warhol.py
index bc8a7aa..e4a9109 100644
--- a/examples/vid_warhol.py
+++ b/examples/vid_warhol.py
@@ -5,7 +5,7 @@
 import cv2
 
 from wrapify.connect.wrapper import MiddlewareCommunicator
-# from wrapify.config.manager import ConfigManager
+from wrapify.config.manager import ConfigManager
 
 """
 Warhol effect on captures from camera
@@ -94,10 +94,7 @@ def cv2_to_pil(img):
         if isinstance(img, Image.Image):
             return img
         else:
-            try:
-                return Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
-            except:
-                return img
+            return Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
 
     @staticmethod
     def pil_to_cv2(img):
@@ -106,7 +103,7 @@ def pil_to_cv2(img):
         else:
             return img
 
-    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/darken_bg", carrier="mcast", width="$img_width", height="$img_height", rgb=True, should_wait=True)
+    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/darken_bg", carrier="mcast", width="$img_width", height="$img_height", rgb=True, should_wait=False)
     def darken_bg(self, img, color, img_width, img_height):
         img = self.cv2_to_pil(img)
         # composite image on top of a single-color image, effectively turning all transparent parts to that color
@@ -115,7 +112,7 @@ def darken_bg(self, img, color, img_width, img_height):
         masked_img = self.pil_to_cv2(masked_img)
         return masked_img,
 
-    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/color_bg_fg", carrier="mcast", width="$img_width", height="$img_height", rgb=True, should_wait=True)
+    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/color_bg_fg", carrier="mcast", width="$img_width", height="$img_height", rgb=True, should_wait=False)
     def color_bg_fg(self, img, bg_color, fg_color, img_width, img_height):
         img = self.cv2_to_pil(img)
         # change transparent background to bg_color and change everything non-transparent to fg_color
@@ -125,11 +122,11 @@ def color_bg_fg(self, img, bg_color, fg_color, img_width, img_height):
         masked_img = self.pil_to_cv2(masked_img)
         return masked_img,
 
-    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/white_to_color", carrier="mcast", width="$img_width", height="$img_height", rgb=True, should_wait=True)
+    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/white_to_color", carrier="mcast", width="$img_width", height="$img_height", rgb=True, should_wait=False)
     def white_to_color(self, img, color, img_width, img_height):
         img = self.cv2_to_pil(img).convert('RGBA')
         # change all colors close to white and non-transparent (alpha > 0) to be color
-        threshold = 50
+        threshold = 20
         dist = 10
         arr = np.array(np.asarray(img))
         r, g, b, a = np.rollaxis(arr, axis=-1)
@@ -163,8 +160,8 @@ def make_warhol_single(self, img, bg_color, fg_color, skin_color):
         out = Image.composite(bg_fg_layer, skin_layer, skin_mask)
         return out
 
-    @MiddlewareCommunicator.register([["Image", "yarp", "Warholify", "/vid_warhol/warhol_" + str(x), {"carrier": "mcast", "width": "$img_width", "height": "$img_height", "should_wait": True}] for x in range(9)])
-    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/warhol_combined", carrier="mcast", width="$img_width", height="$img_height", should_wait=True)
+    @MiddlewareCommunicator.register([["Image", "yarp", "Warholify", "/vid_warhol/warhol_" + str(x), {"carrier": "mcast", "width": "$img_width", "height": "$img_height", "should_wait": False}] for x in range(9)])
+    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/warhol_combined", carrier="mcast", width="$img_width", height="$img_height", should_wait=False)
     def combine_to_one(self, warhols, img_width, img_height):
         warhols_new = []
         for warhol in warhols:
@@ -202,7 +199,7 @@ def warholify_images(self, img):
 
         return blank_img
 
-    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/feed", carrier="mcast", width="$img_width", height="$img_height", should_wait=True)
+    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/feed", carrier="mcast", width="$img_width", height="$img_height", should_wait=False)
     def capture_vid(self, img_width, img_height):
         if self.vid_cap is None:
             self.vid_cap = cv2.VideoCapture(self.vid_src)
@@ -222,7 +219,7 @@ def transform(self, img_width=640, img_height=480):
             return img
 
 
-    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/final_img", carrier="mcast", width="$img_width", height="$img_height", rgb=True, should_wait=True)
+    @MiddlewareCommunicator.register("Image", "yarp", "Warholify", "/vid_warhol/final_img", carrier="mcast", width="$img_width", height="$img_height", rgb=True, should_wait=False)
     def display(self, img, img_width, img_height):
         cv2.imshow("Warhol", img)
         cv2.waitKey(1)
@@ -241,7 +238,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 
 def parse_args():
     parser = argparse.ArgumentParser()
-    parser.add_argument("--cfg-file", type=str, default="vid_warhol_cfg1.yml",
+    parser.add_argument("--cfg-file", type=str,
                         help="The transmission mode configuration file")
     parser.add_argument("--vid-src", default=0,
                         help="The video source. A string indicating a filename or an integer indicating the device id")
@@ -252,7 +249,8 @@ def parse_args():
 
 if __name__ == "__main__":
     args = parse_args()
-    print(args.cfg_file)
-    # ConfigManager(args.cfg_file)
+    if args.cfg_file:
+        print(args.cfg_file)
+        ConfigManager(args.cfg_file)
     warholify = Warholify(vid_src=args.vid_src, img_width=args.img_width, img_height=args.img_height)
     warholify.run()
\ No newline at end of file
diff --git a/wrapify/connect/listeners.py b/wrapify/connect/listeners.py
index d593eed..78c7659 100644
--- a/wrapify/connect/listeners.py
+++ b/wrapify/connect/listeners.py
@@ -6,16 +6,23 @@
 
 # TODO (fabawi): The watch dog is not running yet. Relying on lazy listening for now
 class ListenerWatchDog(metaclass=SingletonOptimized):
-    def __init__(self):
+    def __init__(self, repeats=10, inner_repeats=10):
+        self.repeats = repeats
+        self.inner_repeats = inner_repeats
         self.listener_ring = []
 
     def add_listener(self, listener):
         self.listener_ring.append(listener)
 
+    def remove_listener(self, listener):
+        self.listener_ring.remove(listener)
+
     def scan(self):
-        while self.listener_ring:
+        repeats = self.repeats
+        while self.listener_ring and (repeats > 0 | repeats <= -1):
+            repeats -= 1
             for listener in self.listener_ring:
-                found_listener = listener.establish()
+                found_listener = listener.establish(repeats=self.inner_repeats)
                 if found_listener:
                     self.listener_ring.remove(listener)
 
@@ -46,7 +53,20 @@ def __init__(self, name, in_port, carrier="", should_wait=True, **kwargs):
         self.should_wait = should_wait
         self.established = False
 
-    def establish(self, **kwargs):
+    def check_establishment(self, established):
+        if established:
+            self.established = True
+            if not self.should_wait:
+                ListenerWatchDog().remove_listener(self)
+        elif not self.should_wait:
+            ListenerWatchDog().scan()
+            if self in ListenerWatchDog().listener_ring:
+                established = False
+            else:
+                established = True
+        return established
+
+    def establish(self, repeats=-1, **kwargs):
         raise NotImplementedError
 
     def listen(self):
diff --git a/wrapify/connect/publishers.py b/wrapify/connect/publishers.py
index bab881e..0f403dd 100644
--- a/wrapify/connect/publishers.py
+++ b/wrapify/connect/publishers.py
@@ -24,31 +24,52 @@ def scan():
 
 # TODO (fabawi): The watch dog is not running yet. Relying on lazy publishing for now
 class PublisherWatchDog(metaclass=SingletonOptimized):
-    def __init__(self):
+    def __init__(self, repeats=10, inner_repeats=10):
+        self.repeats = repeats
+        self.inner_repeats = inner_repeats
         self.publisher_ring = []
 
     def add_publisher(self, publisher):
         self.publisher_ring.append(publisher)
 
+    def remove_publisher(self, publisher):
+        self.publisher_ring.remove(publisher)
+
     def scan(self):
-        while self.publisher_ring:
+        repeats = self.repeats
+        while self.publisher_ring and (repeats > 0 | repeats <= -1):
+            repeats -= 1
             for publisher in self.publisher_ring:
-                found_listener = publisher.establish()
-                if found_listener:
+                found_publisher= publisher.establish(repeats=self.inner_repeats)
+                if found_publisher:
                     self.publisher_ring.remove(publisher)
 
 
 # TODO (fabawi): Support multiple instance publishing of the same class,
 #  currently only an issue with the output port naming convention
 class Publisher(object):
-    def __init__(self, name, out_port, carrier="", out_port_connect=None, **kwargs):
+    def __init__(self, name, out_port, carrier="", out_port_connect=None, should_wait=True, **kwargs):
         self.__name__ = name
         self.out_port = out_port
         self.carrier = carrier
         self.out_port_connect = out_port + ":out" if out_port_connect is None else out_port_connect
+        self.should_wait = should_wait
         self.established = False
 
-    def establish(self, **kwargs):
+    def check_establishment(self, established):
+        if established:
+            self.established = True
+            if not self.should_wait:
+                PublisherWatchDog().remove_publisher(self)
+        elif not self.should_wait:
+            PublisherWatchDog().scan()
+            if self in PublisherWatchDog().publisher_ring:
+                established = False
+            else:
+                established = True
+        return established
+
+    def establish(self, repeats=-1, **kwargs):
         raise NotImplementedError
 
     def publish(self, obj):
diff --git a/wrapify/connect/wrapper.py b/wrapify/connect/wrapper.py
index 8121588..12f5e58 100644
--- a/wrapify/connect/wrapper.py
+++ b/wrapify/connect/wrapper.py
@@ -24,18 +24,14 @@ def encapsulate(func):
             # define the communication message type (single element)
             if isinstance(data_type, str):
                 return_func_type = data_type + ":" + middleware
-                return_func_listen = lsn.Listeners.registry[return_func_type]
-                return_func_publish = pub.Publishers.registry[return_func_type]
                 return_func_args = args
                 return_func_kwargs = kwargs
 
             # define the communication message type (list for single return). NOTE: supports 1 layer depth only
             elif isinstance(data_type, list):
-                return_func_listen, return_func_publish, return_func_args, return_func_kwargs, return_func_type = [], [], [], [], []
+                return_func_args, return_func_kwargs, return_func_type = [], [], []
                 for arg in data_type:
                     data_spec = arg[0] + ":" + arg[1]
-                    return_func_listen.append(lsn.Listeners.registry[data_spec])
-                    return_func_publish.append(pub.Publishers.registry[data_spec])
                     return_func_args.append([a for a in arg[2:] if not isinstance(a, dict)])
                     return_func_kwargs.append(*[a for a in arg[2:] if isinstance(a, dict)])
                     return_func_type.append(data_spec)
@@ -50,15 +46,11 @@ def encapsulate(func):
             func_qualname = func.__qualname__
             if func_qualname in cls.__registry:
                 cls.__registry[func_qualname]["communicator"].append({
-                    "return_func_listen": return_func_listen,
-                    "return_func_publish": return_func_publish,
                     "return_func_args": return_func_args,
                     "return_func_kwargs": return_func_kwargs,
                     "return_func_type": return_func_type})
             else:
                 cls.__registry[func_qualname] = {"communicator": [{
-                    "return_func_listen": return_func_listen,
-                    "return_func_publish": return_func_publish,
                     "return_func_args": return_func_args,
                     "return_func_kwargs": return_func_kwargs,
                     "return_func_type": return_func_type}]}
@@ -69,16 +61,15 @@ def wrapper(*wds, **kwds):  # Triggers on calling the function
                 # execute the function as usual
                 if cls._MiddlewareCommunicator__registry[func.__qualname__]["mode"] is None:
                     return func(*wds, **kwds)
-                else:
-                    instance_address = hex(id(wds[0]))
-                    instance_id = cls._MiddlewareCommunicator__registry[func.__qualname__]["__WRAPIFY_INSTANCES"].index(instance_address) + 1
-                    instance_id = "." + str(instance_id) if instance_id > 1 else ""
 
-                    kwd = get_default_args(func)
-                    kwd.update(kwds)
-                    cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["args"] = wds
-                    cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["kwargs"] = kwd
+                instance_address = hex(id(wds[0]))
+                instance_id = cls._MiddlewareCommunicator__registry[func.__qualname__]["__WRAPIFY_INSTANCES"].index(instance_address) + 1
+                instance_id = "." + str(instance_id) if instance_id > 1 else ""
 
+                kwd = get_default_args(func)
+                kwd.update(kwds)
+                cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["args"] = wds
+                cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["kwargs"] = kwd
 
                 # publishes the functions returns
                 if cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["mode"] == "publish":
@@ -90,14 +81,15 @@ def wrapper(*wds, **kwds):  # Triggers on calling the function
                             if isinstance(communicator["return_func_type"], str):
                                 new_args, new_kwargs = match_args(
                                     communicator["return_func_args"], communicator["return_func_kwargs"], wds[1:], kwd)
-                                communicator["wrapped_executor"] = communicator["return_func_publish"](*new_args, **new_kwargs)
+
+                                communicator["wrapped_executor"] = pub.Publishers.registry[communicator["return_func_type"]](*new_args, **new_kwargs)
                             # list for single return
                             elif isinstance(communicator["return_func_type"], list):
                                 communicator["wrapped_executor"] = []
                                 for comm_idx in range(len(communicator["return_func_type"])):
                                     new_args, new_kwargs = match_args(
                                         communicator["return_func_args"][comm_idx], communicator["return_func_kwargs"][comm_idx], wds[1:], kwd)
-                                    communicator["wrapped_executor"].append(communicator["return_func_publish"][comm_idx](*new_args, **new_kwargs))
+                                    communicator["wrapped_executor"].append(pub.Publishers.registry[communicator["return_func_type"][comm_idx]](*new_args, **new_kwargs))
                     returns = func(*wds, **kwds)
                     for ret_idx, ret in enumerate(returns):
                         wrp_exec = cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["communicator"][ret_idx]["wrapped_executor"]
@@ -119,13 +111,13 @@ def wrapper(*wds, **kwds):  # Triggers on calling the function
                             # single element
                             if isinstance(communicator["return_func_type"], str):
                                 new_args, new_kwargs = match_args(communicator["return_func_args"], communicator["return_func_kwargs"], wds[1:], kwd)
-                                communicator["wrapped_executor"] = communicator["return_func_listen"](*new_args, **new_kwargs)
+                                communicator["wrapped_executor"] = lsn.Listeners.registry[communicator["return_func_type"]](*new_args, **new_kwargs)
                             # list for single return
                             elif isinstance(communicator["return_func_type"], list):
                                 communicator["wrapped_executor"] = []
                                 for comm_idx in range(len(communicator["return_func_type"])):
                                     new_args, new_kwargs = match_args(communicator["return_func_args"][comm_idx], communicator["return_func_kwargs"][comm_idx], wds[1:], kwd)
-                                    communicator["wrapped_executor"].append(communicator["return_func_listen"][comm_idx](*new_args, **new_kwargs))
+                                    communicator["wrapped_executor"].append(lsn.Listeners.registry[communicator["return_func_type"][comm_idx]](*new_args, **new_kwargs))
                     cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["last_results"] = []
                     for ret_idx in range(len(cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["communicator"])):
                         wrp_exec = cls._MiddlewareCommunicator__registry[func.__qualname__ + instance_id]["communicator"][ret_idx]["wrapped_executor"]
@@ -152,6 +144,8 @@ def wrapper(*wds, **kwds):  # Triggers on calling the function
         return encapsulate
 
     def activate_communication(self, func, mode):
+        if isinstance(func, str):
+            func = getattr(self, func)
         entry = self.__registry.get(func.__qualname__, None)
         if entry is not None:
             instance_addr = hex(id(self))
diff --git a/wrapify/listeners/yarp.py b/wrapify/listeners/yarp.py
index e3c685b..3dfb2bd 100644
--- a/wrapify/listeners/yarp.py
+++ b/wrapify/listeners/yarp.py
@@ -10,17 +10,29 @@
 
 class YarpListener(Listener):
 
-    def __init__(self, name, in_port, carrier="", should_wait=True, **kwargs):
-        super().__init__(name, in_port, carrier=carrier, should_wait=should_wait, **kwargs)
+    def __init__(self, name, in_port, carrier="", **kwargs):
+        super().__init__(name, in_port, carrier=carrier, **kwargs)
         YarpMiddleware.activate()
 
-    def await_connection(self, port=None):
+    def await_connection(self, port=None, repeats=None):
+        connected = False
         if port is None:
             port = self.in_port
         print("Waiting for input port:", port)
-        while not yarp.Network.exists(port):
-            time.sleep(0.2)
-        print("Connected to input port:", port)
+        if repeats is None:
+            if self.should_wait:
+                repeats = -1
+            else:
+                repeats = 1
+
+            while repeats > 0 or repeats <= -1:
+                repeats -= 1
+                connected = yarp.Network.exists(port)
+                if connected:
+                    print("Connected to input port:", port)
+                    break
+                time.sleep(0.2)
+        return connected
 
     def read_port(self, port):
         while True:
@@ -34,23 +46,27 @@ def read_port(self, port):
 @Listeners.register("NativeObject", "yarp")
 class YarpNativeObjectListener(YarpListener):
 
-    def __init__(self, name, in_port, carrier="", should_wait=True, load_torch_device=None, **kwargs):
-        super().__init__(name, in_port, carrier=carrier, should_wait=should_wait, **kwargs)
+    def __init__(self, name, in_port, carrier="", load_torch_device=None, **kwargs):
+        super().__init__(name, in_port, carrier=carrier, **kwargs)
         self._json_object_hook = JsonDecodeHook(torch_device=load_torch_device).object_hook
         self._port = self._netconnect = None
-        ListenerWatchDog().add_listener(self)
-
-    def establish(self):
-        self.await_connection()
-        self._port = yarp.BufferedPortBottle()
-        rnd_id = str(np.random.randint(100000, size=1)[0])
-        self._port.open(self.in_port + ":in" + rnd_id)
-        self._netconnect = yarp.Network.connect(self.in_port, self.in_port + ":in" + rnd_id, self.carrier)
-        self.established = True
+        if not self.should_wait:
+            ListenerWatchDog().add_listener(self)
+
+    def establish(self, repeats=None, **kwargs):
+        established = self.await_connection(repeats=repeats)
+        if established:
+            self._port = yarp.BufferedPortBottle()
+            rnd_id = str(np.random.randint(100000, size=1)[0])
+            self._port.open(self.in_port + ":in" + rnd_id)
+            self._netconnect = yarp.Network.connect(self.in_port, self.in_port + ":in" + rnd_id, self.carrier)
+        return self.check_establishment(established)
 
     def listen(self):
         if not self.established:
-            self.establish()
+            established = self.establish()
+            if not established:
+                return None
         obj = self.read_port(self._port)
         return json.loads(obj.get(0).asString(), object_hook=self._json_object_hook) if obj is not None else None
 
@@ -58,30 +74,34 @@ def listen(self):
 @Listeners.register("Image", "yarp")
 class YarpImageListener(YarpListener):
 
-    def __init__(self, name, in_port, carrier="", should_wait=True, width=-1, height=-1, rgb=True, fp=False, **kwargs):
-        super().__init__(name, in_port, carrier=carrier, should_wait=should_wait, **kwargs)
+    def __init__(self, name, in_port, carrier="", width=-1, height=-1, rgb=True, fp=False, **kwargs):
+        super().__init__(name, in_port, carrier=carrier, **kwargs)
         self.width = width
         self.height = height
         self.rgb = rgb
         self.fp = fp
         self._port = self._type = self._netconnect = None
-        ListenerWatchDog().add_listener(self)
-
-    def establish(self):
-        self.await_connection()
-        if self.rgb:
-            self._port = yarp.BufferedPortImageRgbFloat() if self.fp else yarp.BufferedPortImageRgb()
-        else:
-            self._port = yarp.BufferedPortImageFloat() if self.fp else yarp.BufferedPortImageMono()
-        self._type = np.float32 if self.fp else np.uint8
-        in_port_connect = f"{self.in_port}:in{np.random.randint(100000, size=1).item()}"
-        self._port.open(in_port_connect)
-        self._netconnect = yarp.Network.connect(self.in_port, in_port_connect, self.carrier)
-        self.established = True
+        if not self.should_wait:
+            ListenerWatchDog().add_listener(self)
+
+    def establish(self, repeats=None, **kwargs):
+        established = self.await_connection(repeats=repeats)
+        if established:
+            if self.rgb:
+                self._port = yarp.BufferedPortImageRgbFloat() if self.fp else yarp.BufferedPortImageRgb()
+            else:
+                self._port = yarp.BufferedPortImageFloat() if self.fp else yarp.BufferedPortImageMono()
+            self._type = np.float32 if self.fp else np.uint8
+            in_port_connect = f"{self.in_port}:in{np.random.randint(100000, size=1).item()}"
+            self._port.open(in_port_connect)
+            self._netconnect = yarp.Network.connect(self.in_port, in_port_connect, self.carrier)
+        return self.check_establishment(established)
 
     def listen(self):
         if not self.established:
-            self.establish()
+            established = self.establish()
+            if not established:
+                return None
         yarp_img = self.read_port(self._port)
         if yarp_img is None:
             return None
@@ -109,27 +129,32 @@ def __del__(self):
 @Listeners.register("AudioChunk", "yarp")
 class YarpAudioChunkListener(YarpImageListener):
 
-    def __init__(self, name, in_port, carrier="", should_wait=True, channels=1, rate=44100, chunk=-1, **kwargs):
-        super().__init__(name, in_port, carrier=carrier, should_wait=should_wait, width=chunk, height=channels, rgb=False, fp=True, **kwargs)
+    def __init__(self, name, in_port, carrier="", channels=1, rate=44100, chunk=-1, **kwargs):
+        super().__init__(name, in_port, carrier=carrier, width=chunk, height=channels, rgb=False, fp=True, **kwargs)
         self.channels = channels
         self.rate = rate
         self.chunk = chunk
         self._dummy_sound = self._dummy_port = self._dummy_netconnect = None
-        ListenerWatchDog().add_listener(self)
-
-    def establish(self):
-        self.await_connection(port=self.in_port + "_SND")
-        # create a dummy sound object for transmitting the sound props. This could be cleaner but left for future impl.
-        rnd_id = str(np.random.randint(100000, size=1)[0])
-        self._dummy_port = yarp.Port()
-        self._dummy_port.open(self.in_port + "_SND:in" + rnd_id)
-        self._dummy_netconnect = yarp.Network.connect(self.in_port + "_SND", self.in_port + "_SND:in" + rnd_id, self.carrier)
-        super(YarpAudioChunkListener, self).establish()
-        self._dummy_sound = yarp.Sound()
-        self._dummy_port.read(self._dummy_sound)
-        self.rate = self._dummy_sound.getFrequency()
-        self.width = self.chunk = self._dummy_sound.getSamples()
-        self.height = self.channels = self._dummy_sound.getChannels()
+        if not self.should_wait:
+            ListenerWatchDog().add_listener(self)
+
+    def establish(self, repeats=None, **kwargs):
+        established = self.await_connection(port=self.in_port + "_SND", repeats=repeats)
+        if established:
+            # create a dummy sound object for transmitting the sound props. This could be cleaner but left for future impl.
+            rnd_id = str(np.random.randint(100000, size=1)[0])
+            self._dummy_port = yarp.Port()
+            self._dummy_port.open(self.in_port + "_SND:in" + rnd_id)
+            self._dummy_netconnect = yarp.Network.connect(self.in_port + "_SND", self.in_port + "_SND:in" + rnd_id, self.carrier)
+        established = self.check_establishment(established)
+        established_parent = super(YarpAudioChunkListener, self).establish(repeats=repeats)
+        if established_parent:
+            self._dummy_sound = yarp.Sound()
+            # self._dummy_port.read(self._dummy_sound)
+            # self.rate = self._dummy_sound.getFrequency()
+            # self.width = self.chunk = self._dummy_sound.getSamples()
+            # self.height = self.channels = self._dummy_sound.getChannels()
+        return established
 
     def listen(self):
         return super().listen(), self.rate
@@ -142,7 +167,6 @@ def close(self):
 
 @Listeners.register("Properties", "yarp")
 class YarpPropertiesListener(YarpListener):
-
     def __init__(self, name, in_port, **kwargs):
         super().__init__(name, in_port, **kwargs)
         raise NotImplementedError
diff --git a/wrapify/publishers/ros.py b/wrapify/publishers/ros.py
index 20c252c..0af849a 100644
--- a/wrapify/publishers/ros.py
+++ b/wrapify/publishers/ros.py
@@ -18,13 +18,24 @@ def __init__(self, name, out_port, carrier="", out_port_connect=None, queue_size
         ROSMiddleware.activate()
         self.queue_size = queue_size
 
-    def await_connection(self, publisher, out_port=None):
+    def await_connection(self, publisher, out_port=None, repeats=None):
+        connected = False
         if out_port is None:
             out_port = self.out_port
         print("Waiting for topic subscriber:", out_port)
-        while publisher.get_num_connections() < 1:
-            time.sleep(0.02)
+        if repeats is None:
+            if self.should_wait:
+                repeats = -1
+            else:
+                repeats = 1
+            while repeats > 0 or repeats <= -1:
+                repeats -= 1
+                connected = publisher.get_num_connections() < 1
+                if connected:
+                    break
+                time.sleep(0.02)
         print("Topic subscriber connected:", out_port)
+        return connected
 
 
 @Publishers.register("NativeObject", "ros")
@@ -33,16 +44,21 @@ class ROSNativeObjectPublisher(ROSPublisher):
     def __init__(self, name, out_port, carrier="", out_port_connect=None, queue_size=5, **kwargs):
         super().__init__(name, out_port, carrier=carrier, out_port_connect=out_port_connect, queue_size=queue_size, **kwargs)
         self._publisher = None
-        PublisherWatchDog().add_publisher(self)
+        if not self.should_wait:
+            PublisherWatchDog().add_publisher(self)
 
-    def establish(self):
+    def establish(self, repeats=None, **kwargs):
         self._publisher = rospy.Publisher(self.out_port, std_msgs.msg.String, queue_size=self.queue_size)
-        self.await_connection(self._publisher)
-        self.established = True
+        established = self.await_connection(self._publisher, repeats=repeats)
+        return self.check_establishment(established)
 
     def publish(self, obj):
         if not self.established:
-            self.establish()
+            established = self.establish()
+            if not established:
+                return
+            else:
+                time.sleep(0.2)
         obj_str = json.dumps(obj, cls=JsonEncoder)
         self._publisher.publish(obj_str)
 
@@ -63,16 +79,21 @@ def __init__(self, name, out_port, carrier="", out_port_connect=None, width=-1,
             self._encoding = 'bgr8' if self.rgb else 'mono8'
             self._type = np.uint8
         self._publisher = None
-        PublisherWatchDog().add_publisher(self)
+        if not self.should_wait:
+            PublisherWatchDog().add_publisher(self)
 
-    def establish(self):
+    def establish(self, repeats=None, **kwargs):
         self._publisher = rospy.Publisher(self.out_port, sensor_msgs.msg.Image, queue_size=self.queue_size)
-        self.await_connection(self._publisher)
-        self.established = True
+        established = self.await_connection(self._publisher)
+        return self.check_establishment(established)
 
     def publish(self, img):
         if not self.established:
-            self.establish()
+            established = self.establish()
+            if not established:
+                return
+            else:
+                time.sleep(0.2)
         if 0 < self.width != img.shape[1] or 0 < self.height != img.shape[0] or not ((img.ndim == 2 and not self.rgb) or (img.ndim == 3 and self.rgb and img.shape[2] == 3)):
             raise ValueError("Incorrect image shape for publisher")
         img = np.require(img, dtype=self._type, requirements='C')
@@ -96,16 +117,21 @@ def __init__(self, name, out_port, carrier="", out_port_connect=None, channels=1
         self.rate = rate
         self.chunk = chunk
         self._publisher = None
-        PublisherWatchDog().add_publisher(self)
+        if not self.should_wait:
+            PublisherWatchDog().add_publisher(self)
 
-    def establish(self, **kwargs):
+    def establish(self, repeats=None, **kwargs):
         self._publisher = rospy.Publisher(self.out_port, sensor_msgs.msg.Image, queue_size=self.queue_size)
-        self.await_connection(self._publisher)
-        self.established = True
+        established = self.await_connection(self._publisher)
+        return self.check_establishment(established)
 
     def publish(self, aud):
         if not self.established:
-            self.establish()
+            established = self.establish()
+            if not established:
+                return
+            else:
+                time.sleep(0.2)
         aud, rate = aud
         if rate != self.rate:
             raise ValueError("Incorrect audio rate for publisher")
@@ -127,7 +153,6 @@ def publish(self, aud):
 
 @Publishers.register("Properties", "ros")
 class ROSPropertiesPublisher(ROSPublisher):
-
     def __init__(self, name, out_port, **kwargs):
         super().__init__(name, out_port, **kwargs)
         raise NotImplementedError
diff --git a/wrapify/publishers/yarp.py b/wrapify/publishers/yarp.py
index d4abd09..713d90d 100644
--- a/wrapify/publishers/yarp.py
+++ b/wrapify/publishers/yarp.py
@@ -14,13 +14,25 @@ def __init__(self, name, out_port, carrier="", out_port_connect=None, **kwargs):
         super().__init__(name, out_port, carrier=carrier, out_port_connect=out_port_connect, **kwargs)
         YarpMiddleware.activate()
 
-    def await_connection(self, port, out_port=None):
+    def await_connection(self, port, out_port=None, repeats=None):
+        connected = False
         if out_port is None:
             out_port = self.out_port
         print("Waiting for output connection:", out_port)
-        while port.getOutputCount() < 1:
-            time.sleep(0.02)
+        if repeats is None:
+            if self.should_wait:
+                repeats = -1
+            else:
+                repeats = 1
+            while repeats > 0 or repeats <= -1:
+                repeats -= 1
+                connected = port.getOutputCount() < 1
+                if connected:
+                    break
+                time.sleep(0.02)
         print("Output connection established:", out_port)
+        return connected
+
 
 
 @Publishers.register("NativeObject", "yarp")
@@ -39,18 +51,23 @@ def __init__(self, name, out_port, carrier="", out_port_connect=None, **kwargs):
         """
         super().__init__(name, out_port, carrier=carrier, out_port_connect=out_port_connect, **kwargs)
         self._port = self._netconnect = None
-        PublisherWatchDog().add_publisher(self)
+        if not self.should_wait:
+            PublisherWatchDog().add_publisher(self)
 
-    def establish(self):
+    def establish(self, repeats=None, **kwargs):
         self._port = yarp.BufferedPortBottle()
         self._port.open(self.out_port)
         self._netconnect = yarp.Network.connect(self.out_port, self.out_port_connect, self.carrier)
-        self.await_connection(self._port)
-        self.established = True
+        established = self.await_connection(self._port, repeats=repeats)
+        return self.check_establishment(established)
 
     def publish(self, obj):
         if not self.established:
-            self.establish()
+            established = self.establish()
+            if not established:
+                return
+            else:
+                time.sleep(0.2)
         obj = json.dumps(obj, cls=JsonEncoder)
         oobj = self._port.prepare()
         oobj.clear()
@@ -79,9 +96,10 @@ def __init__(self, name, out_port, carrier="", out_port_connect=None, width=-1,
         self.rgb = rgb
         self.fp = fp
         self._port = self._type = self._netconnect = None
-        PublisherWatchDog().add_publisher(self)
+        if not self.should_wait:
+            PublisherWatchDog().add_publisher(self)
 
-    def establish(self):
+    def establish(self, repeats=None, **kwargs):
         if self.rgb:
             self._port = yarp.BufferedPortImageRgbFloat() if self.fp else yarp.BufferedPortImageRgb()
         else:
@@ -89,8 +107,8 @@ def establish(self):
         self._type = np.float32 if self.fp else np.uint8
         self._port.open(self.out_port)
         self._netconnect = yarp.Network.connect(self.out_port, self.out_port_connect, self.carrier)
-        self.await_connection(self._port)
-        self.established = True
+        established = self.await_connection(self._port, repeats=repeats)
+        return self.check_establishment(established)
 
     def publish(self, img):
         """
@@ -99,7 +117,11 @@ def publish(self, img):
         :return: None
         """
         if not self.established:
-            self.establish()
+            established = self.establish()
+            if not established:
+                return
+            else:
+                time.sleep(0.2)
         if 0 < self.width != img.shape[1] or 0 < self.height != img.shape[0] or not ((img.ndim == 2 and not self.rgb) or (img.ndim == 3 and self.rgb and img.shape[2] == 3)):
             raise ValueError("Incorrect image shape for publisher")
         img = np.require(img, dtype=self._type, requirements='C')
@@ -142,9 +164,10 @@ def __init__(self, name, out_port, carrier="", out_port_connect=None, channels=1
         self.rate = rate
         self.chunk = chunk
         self._dummy_sound = self._dummy_port = self._dummy_netconnect = None
-        PublisherWatchDog().add_publisher(self)
+        if not self.should_wait:
+            PublisherWatchDog().add_publisher(self)
 
-    def establish(self):
+    def establish(self, repeats=None, **kwargs):
         # create a dummy sound object for transmitting the sound props. This could be cleaner but left for future impl.
         self._dummy_port = yarp.Port()
         self._dummy_port.open(self.out_port + "_SND")
@@ -152,9 +175,11 @@ def establish(self):
         self._dummy_sound = yarp.Sound()
         self._dummy_sound.setFrequency(self.rate)
         self._dummy_sound.resize(self.chunk, self.channels)
-        self.await_connection(self._dummy_port, out_port=self.out_port + "_SND")
-        super(YarpAudioChunkPublisher, self).establish()
-        self._dummy_port.write(self._dummy_sound)
+        established = self.await_connection(self._dummy_port, out_port=self.out_port + "_SND")
+        if established:
+            super(YarpAudioChunkPublisher, self).establish(repeats=repeats)
+            self._dummy_port.write(self._dummy_sound)
+        return self.check_establishment(established)
 
     def publish(self, aud):
         """
@@ -163,7 +188,11 @@ def publish(self, aud):
         :return: None
         """
         if not self.established:
-            self.establish()
+            established = self.establish()
+            if not established:
+                return
+            else:
+                time.sleep(0.2)
         aud, _ = aud
         if aud is not None:
             oaud = self._port.prepare()

From 15a8538c319670b99d12ef5adaa6211195792000 Mon Sep 17 00:00:00 2001
From: abawi <fares.abawi@uni-hamburg.de>
Date: Thu, 18 Aug 2022 21:39:12 +0200
Subject: [PATCH 4/6] Replaced printing with logging

---
 wrapify/__init__.py         | 5 ++++-
 wrapify/config/manager.py   | 5 +++--
 wrapify/listeners/ros.py    | 8 +++++---
 wrapify/listeners/yarp.py   | 6 ++++--
 wrapify/middlewares/ros.py  | 6 ++++--
 wrapify/middlewares/yarp.py | 6 ++++--
 wrapify/publishers/ros.py   | 6 ++++--
 wrapify/publishers/yarp.py  | 7 ++++---
 8 files changed, 32 insertions(+), 17 deletions(-)

diff --git a/wrapify/__init__.py b/wrapify/__init__.py
index b5ddc7a..6f4f0a0 100644
--- a/wrapify/__init__.py
+++ b/wrapify/__init__.py
@@ -1 +1,4 @@
-__version__ = 0.1
\ No newline at end of file
+__version__ = 0.2
+
+import logging
+logging.getLogger().setLevel(logging.INFO)
diff --git a/wrapify/config/manager.py b/wrapify/config/manager.py
index 534f19e..c1b9e7c 100644
--- a/wrapify/config/manager.py
+++ b/wrapify/config/manager.py
@@ -1,4 +1,5 @@
 import yaml
+import logging
 
 from wrapify.utils import SingletonOptimized
 
@@ -14,10 +15,10 @@ def __init__(self, config):
         """
         if isinstance(config, str):
             self.config = self.__loadfile__(config)
-            print("loaded configuration", self.config)
+            logging.info(f"Loaded Wrapify configuration: {self.config}")
         elif isinstance(config, dict):
             self.config = config
-            print("loaded configuration", self.config)
+            logging.info(f"Loaded Wrapify configuration: {self.config}")
         else:
             self.config = []
 
diff --git a/wrapify/listeners/ros.py b/wrapify/listeners/ros.py
index 007abbc..5c69024 100644
--- a/wrapify/listeners/ros.py
+++ b/wrapify/listeners/ros.py
@@ -1,5 +1,7 @@
 import json
+import logging
 import queue
+
 import numpy as np
 import rospy
 import std_msgs.msg
@@ -45,7 +47,7 @@ def _message_callback(self, data):
         try:
             self._queue.put(data.data, block=False)
         except queue.Full:
-            print(f"Discarding data because listener queue is full: {self.in_port}")
+            logging.warning(f"Discarding data because listener queue is full: {self.in_port}")
 
 
 @Listeners.register("Image", "ros")
@@ -92,7 +94,7 @@ def _message_callback(self, data):
         try:
             self._queue.put((data.height, data.width, data.encoding, data.is_bigendian, data.data), block=False)
         except queue.Full:
-            print(f"Discarding data because listener queue is full: {self.in_port}")
+            logging.warning(f"Discarding data because listener queue is full: {self.in_port}")
 
 
 @Listeners.register("AudioChunk", "ros")
@@ -129,7 +131,7 @@ def _message_callback(self, data):
         try:
             self._queue.put((data.height, data.width, data.encoding, data.is_bigendian, data.data), block=False)
         except queue.Full:
-            print(f"Discarding data because listener queue is full: {self.in_port}")
+            logging.warning(f"Discarding data because listener queue is full: {self.in_port}")
 
 
 @Listeners.register("Properties", "ros")
diff --git a/wrapify/listeners/yarp.py b/wrapify/listeners/yarp.py
index 3dfb2bd..19ef5fb 100644
--- a/wrapify/listeners/yarp.py
+++ b/wrapify/listeners/yarp.py
@@ -1,5 +1,7 @@
+import logging
 import json
 import time
+
 import numpy as np
 import yarp
 
@@ -18,7 +20,7 @@ def await_connection(self, port=None, repeats=None):
         connected = False
         if port is None:
             port = self.in_port
-        print("Waiting for input port:", port)
+        logging.info("Waiting for input port:", port)
         if repeats is None:
             if self.should_wait:
                 repeats = -1
@@ -29,7 +31,7 @@ def await_connection(self, port=None, repeats=None):
                 repeats -= 1
                 connected = yarp.Network.exists(port)
                 if connected:
-                    print("Connected to input port:", port)
+                    logging.info("Connected to input port:", port)
                     break
                 time.sleep(0.2)
         return connected
diff --git a/wrapify/middlewares/ros.py b/wrapify/middlewares/ros.py
index 376ca65..54cec63 100644
--- a/wrapify/middlewares/ros.py
+++ b/wrapify/middlewares/ros.py
@@ -1,4 +1,6 @@
+import logging
 import atexit
+
 import rospy
 
 from wrapify.utils import SingletonOptimized
@@ -11,11 +13,11 @@ def activate():
         ROSMiddleware()
 
     def __init__(self):
-        print("Initialising ROS middleware")
+        logging.info("Initialising ROS middleware")
         rospy.init_node('wrapify', anonymous=True, disable_signals=True)
         atexit.register(self.deinit)
 
     @staticmethod
     def deinit():
-        print("Deinitialising ROS middleware")
+        logging.info("Deinitialising ROS middleware")
         rospy.signal_shutdown('Deinit')
diff --git a/wrapify/middlewares/yarp.py b/wrapify/middlewares/yarp.py
index 0e38324..ffd575d 100644
--- a/wrapify/middlewares/yarp.py
+++ b/wrapify/middlewares/yarp.py
@@ -1,4 +1,6 @@
+import logging
 import atexit
+
 import yarp
 
 from wrapify.utils import SingletonOptimized
@@ -11,11 +13,11 @@ def activate():
         YarpMiddleware()
 
     def __init__(self):
-        print("Initialising YARP middleware")
+        logging.info("Initialising YARP middleware")
         yarp.Network.init()
         atexit.register(self.deinit)
 
     @staticmethod
     def deinit():
-        print("Deinitialising YARP middleware")
+        logging.info("Deinitialising YARP middleware")
         yarp.Network.fini()
diff --git a/wrapify/publishers/ros.py b/wrapify/publishers/ros.py
index 0af849a..6a69436 100644
--- a/wrapify/publishers/ros.py
+++ b/wrapify/publishers/ros.py
@@ -1,6 +1,8 @@
+import logging
 import sys
 import json
 import time
+
 import numpy as np
 import rospy
 import std_msgs.msg
@@ -22,7 +24,7 @@ def await_connection(self, publisher, out_port=None, repeats=None):
         connected = False
         if out_port is None:
             out_port = self.out_port
-        print("Waiting for topic subscriber:", out_port)
+        logging.info(f"Waiting for topic subscriber: {out_port}")
         if repeats is None:
             if self.should_wait:
                 repeats = -1
@@ -34,7 +36,7 @@ def await_connection(self, publisher, out_port=None, repeats=None):
                 if connected:
                     break
                 time.sleep(0.02)
-        print("Topic subscriber connected:", out_port)
+        logging.info(f"Topic subscriber connected: {out_port}")
         return connected
 
 
diff --git a/wrapify/publishers/yarp.py b/wrapify/publishers/yarp.py
index 713d90d..6a2d39f 100644
--- a/wrapify/publishers/yarp.py
+++ b/wrapify/publishers/yarp.py
@@ -1,5 +1,7 @@
+import logging
 import json
 import time
+
 import numpy as np
 import yarp
 
@@ -18,7 +20,7 @@ def await_connection(self, port, out_port=None, repeats=None):
         connected = False
         if out_port is None:
             out_port = self.out_port
-        print("Waiting for output connection:", out_port)
+        logging.info(f"Waiting for output connection: {out_port}")
         if repeats is None:
             if self.should_wait:
                 repeats = -1
@@ -30,11 +32,10 @@ def await_connection(self, port, out_port=None, repeats=None):
                 if connected:
                     break
                 time.sleep(0.02)
-        print("Output connection established:", out_port)
+        logging.info(f"Output connection established: {out_port}")
         return connected
 
 
-
 @Publishers.register("NativeObject", "yarp")
 class YarpNativeObjectPublisher(YarpPublisher):
     """

From 15e2340727d8f4262c576f2b6f27de8add6c9951 Mon Sep 17 00:00:00 2001
From: abawi <fares.abawi@uni-hamburg.de>
Date: Thu, 18 Aug 2022 21:41:59 +0200
Subject: [PATCH 5/6] Replaced printing with logging

---
 wrapify/listeners/yarp.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/wrapify/listeners/yarp.py b/wrapify/listeners/yarp.py
index 19ef5fb..e99c6eb 100644
--- a/wrapify/listeners/yarp.py
+++ b/wrapify/listeners/yarp.py
@@ -20,7 +20,7 @@ def await_connection(self, port=None, repeats=None):
         connected = False
         if port is None:
             port = self.in_port
-        logging.info("Waiting for input port:", port)
+        logging.info(f"Waiting for input port: {port}")
         if repeats is None:
             if self.should_wait:
                 repeats = -1
@@ -31,7 +31,7 @@ def await_connection(self, port=None, repeats=None):
                 repeats -= 1
                 connected = yarp.Network.exists(port)
                 if connected:
-                    logging.info("Connected to input port:", port)
+                    logging.info(f"Connected to input port: {port}")
                     break
                 time.sleep(0.2)
         return connected

From 78f2a7e3dbe3cb3d251dcaa4608ef59600da4fcf Mon Sep 17 00:00:00 2001
From: abawi <fares.abawi@uni-hamburg.de>
Date: Thu, 18 Aug 2022 21:47:09 +0200
Subject: [PATCH 6/6] Restored synchronous (should_wait) in pytorch example

---
 examples/torch_tensor.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/torch_tensor.py b/examples/torch_tensor.py
index c8e65e3..769f403 100644
--- a/examples/torch_tensor.py
+++ b/examples/torch_tensor.py
@@ -33,9 +33,9 @@ def parse_args():
     class Notify(MiddlewareCommunicator):
 
         @MiddlewareCommunicator.register("NativeObject", args.mware, "Notify", "/notify/test_native_exchange",
-                                         carrier="", should_wait=False, load_torch_device='cpu')
+                                         carrier="", should_wait=True, load_torch_device='cpu')
         @MiddlewareCommunicator.register("NativeObject", args.mware, "Notify", "/notify/test_native_exchange2",
-                                         carrier="", should_wait=False, load_torch_device='cpu')
+                                         carrier="", should_wait=True, load_torch_device='cpu')
         def exchange_object(self, msg):
             ret = {"message": msg,
                    "torch_ones": torch.ones((2, 4), device='cpu'),