Switched from print_time to proper logging

Author: MaxF12

examples/echo_example/echoServer.py

@@ -1,25 +1,27 @@
 import asyncio
 import sys
 import argparse
+
 sys.path.append(sys.path[0] + "/../..")
 import pytaps as taps  # noqa: E402
 
-color = "blue"
+logger = taps.setup_logger("Echo Server", "yellow")
 
 
-class TestServer():
+class TestServer:
     """A simple echo server. Listens using TCP by default,
        but can also use UDP.
 
     """
+
     def __init__(self, reliable=True):
         self.preconnection = None
         self.loop = asyncio.get_event_loop()
         self.connection = None
         self.reliable = reliable
 
     async def handle_connection_received(self, connection):
-        taps.print_time("Received new Connection.", color)
+        logger.info("Received new Connection.")
         self.connection = connection
         self.connection.on_received_partial(self.handle_received_partial)
         self.connection.on_received(self.handle_received)
@@ -30,26 +32,26 @@ async def handle_connection_received(self, connection):
 
     async def handle_received_partial(self, data, context, end_of_message,
                                       connection):
-        taps.print_time("Received partial message " + str(data) + ".", color)
+        logger.info("Received partial message " + str(data) + ".")
         await self.connection.receive(min_incomplete_length=1, max_length=5)
         msgref = await self.connection.send_message(data)
 
     async def handle_received(self, data, context, connection):
-        taps.print_time("Received message " + str(data) + ".", color)
+        logger.info("Received message " + str(data) + ".")
         await self.connection.receive(min_incomplete_length=1, max_length=5)
         await self.connection.send_message(data)
 
     async def handle_listen_error(self):
-        taps.print_time("Listen Error occured.", color)
+        logger.warn("Listen Error occured.")
         self.loop.stop()
 
     async def handle_sent(self, message_ref, connection):
-        taps.print_time("Sent cb received, message " + str(message_ref) +
-                        " has been sent.", color)
+        logger.info("Sent cb received, message " + str(message_ref) +
+                    " has been sent.")
         # self.connection.close()
 
     async def handle_stopped(self):
-        taps.print_time("Listener has been stopped")
+        logger.info("Listener has been stopped")
 
     async def main(self, args):
         # Create endpoint object
@@ -61,13 +63,13 @@ async def main(self, args):
         if args.local_host:
             lp.with_hostname(args.local_host)
         # If nothing to listen on has been specified, listen on localhost
-        if not args.interface and not args.local_address\
-           and not args.local_host:
+        if not args.interface and not args.local_address \
+                and not args.local_host:
             lp.with_hostname("localhost")
         if args.local_port:
             lp.with_port(args.local_port)
 
-        taps.print_time("Created endpoint objects.", color)
+        logger.info("Created endpoint objects.")
 
         sp = None
         if args.secure or args.trust_ca or args.local_identity:
@@ -77,7 +79,7 @@ async def main(self, args):
                 sp.add_trust_ca(args.trust_ca)
             if args.local_identity:
                 sp.add_identity(args.local_identity)
-            taps.print_time("Created SecurityParameters.", color)
+            logger.info("Created SecurityParameters.")
 
         tp = taps.TransportProperties()
         tp.ignore("congestion-control")
@@ -91,7 +93,7 @@ async def main(self, args):
                                                 transport_properties=tp,
                                                 security_parameters=sp)
         self.preconnection.on_connection_received(
-                                            self.handle_connection_received)
+            self.handle_connection_received)
         self.preconnection.on_listen_error(self.handle_listen_error)
         self.preconnection.on_stopped(self.handle_stopped)
         # self.preconnection.frame_with(taps.TlvFramer())

examples/framer_example/framerClient.py

@@ -1,103 +1,103 @@
+import argparse
 import asyncio
 import sys
-import argparse
-import ipaddress
+
 sys.path.append(sys.path[0] + "/../..")
 import pytaps as taps  # noqa: E402
 
-color = "yellow"
+logger = taps.setup_logger("Framer Client", "yellow")
 
 
-class testFramer(taps.Framer):
+class TestFramer(taps.Framer):
     async def start(self, connection):
-        taps.print_time("Framer got new connection", color)
+        logger.info("Framer got new connection")
         return
 
     async def new_sent_message(self, data, context, eom):
-        taps.print_time("Framing new message " + str(data), color)
+        logger.info("Framing new message " + str(data))
         tlv = (data[0] + "/" + str(len(str(data[1]))) + "/" +
                str(data[1]))
         return tlv.encode()
 
     async def handle_received_data(self, connection):
         byte_stream, context, eom = connection.parse()
         byte_stream = byte_stream.decode()
-        taps.print_time("Deframing " + byte_stream, color)
+        logger.info("Deframing " + byte_stream)
         try:
             tlv = byte_stream.split("/")
         except Exception:
-            taps.print_time("Error splitting", color)
+            logger.warn("Error splitting")
             raise taps.DeframingFailed
-            return
 
         if len(tlv) < 3:
-            taps.print_time("Deframing error: missing length," +
-                            " value or type parameter.", color)
+            logger.warning("Deframing error: missing length," +
+                        " value or type parameter.")
             raise taps.DeframingFailed
-            return
 
-        if (len(tlv[2]) < int(tlv[1])):
-            taps.print_time("Deframing error: actual length of message" +
-                            " shorter than indicated", color)
+        if len(tlv[2]) < int(tlv[1]):
+            logger.warning("Deframing error: actual length of message" +
+                        " shorter than indicated")
             raise taps.DeframingFailed
-            return
+
         len_message = len(tlv[0]) + len(tlv[1]) + int(tlv[1]) + 2
         message = (str(tlv[0]), str(tlv[2][0:int(tlv[1])]))
-        return(context, message, len_message, eom)
-        """
+        return context, message, len_message, eom
+
+
+"""
         self.advance_receive_cursor(connection, len_message)
         self.deliver(connection, context, message, eom)
         """
 
 
-class TestClient():
+class TestClient:
     def __init__(self):
         self.connection = None
         self.preconnection = None
         self.loop = asyncio.get_event_loop()
 
     async def handle_received_partial(self, data, context, end_of_message,
                                       connection):
-        taps.print_time("Received partial message " + str(data) + ".", color)
+        logger.info("Received partial message " + str(data) + ".")
         # self.loop.stop()
 
     async def handle_received(self, data, context, connection):
-        taps.print_time("Received message " + str(data) + ".", color)
+        logger.info("Received message " + str(data) + ".")
         # self.loop.stop()
 
     async def handle_sent(self, message_ref, connection):
-        taps.print_time("Sent cb received, message " + str(message_ref) +
-                        " has been sent.", color)
+        logger.info("Sent cb received, message " + str(message_ref) +
+                    " has been sent.")
         await self.connection.receive(min_incomplete_length=1)
 
     async def handle_send_error(self, msg, connection):
-        taps.print_time("SendError cb received.", color)
+        logger.info("SendError cb received.")
         print("Error sending message")
 
     async def handle_initiate_error(self, connection):
-        taps.print_time("InitiateError cb received.", color)
+        logger.info("InitiateError cb received.")
         print("Error init")
         self.loop.stop()
 
     async def handle_closed(self, connection):
-        taps.print_time("Connection closed, stopping event loop.", color)
+        logger.info("Connection closed, stopping event loop.")
         # self.loop.stop()
 
     async def handle_ready(self, connection):
-        taps.print_time("Ready cb received from connection to " +
-                        connection.remote_endpoint.address + ":" +
-                        str(connection.remote_endpoint.port) +
-                        " (hostname: " +
-                        str(connection.remote_endpoint.host_name) +
-                        ")", color)
+        logger.info("Ready cb received from connection to " +
+                    connection.remote_endpoint.address + ":" +
+                    str(connection.remote_endpoint.port) +
+                    " (hostname: " +
+                    str(connection.remote_endpoint.host_name) +
+                    ")")
 
         # Set connection callbacks
         self.connection.on_sent(self.handle_sent)
         self.connection.on_send_error(self.handle_send_error)
         self.connection.on_closed(self.handle_closed)
         self.connection.on_received_partial(self.handle_received_partial)
         self.connection.on_received(self.handle_received)
-        taps.print_time("Connection cbs set.", color)
+        logger.info("Connection cbs set.")
 
         msgref = await self.connection.send_message(("STR", "Hello there"))
         msgref = await self.connection.send_message(("STR", "This is a test"))
@@ -109,7 +109,7 @@ async def handle_ready(self, connection):
         msgref = await self.connection.send_message("Is")
         msgref = await self.connection.send_message("a")
         msgref = await self.connection.send_message("Test")"""
-        taps.print_time("send_message called.", color)
+        logger.info("send_message called.")
 
     async def main(self, args):
 
@@ -132,7 +132,7 @@ async def main(self, args):
             if args.local_port:
                 lp.with_port(args.local_port)
 
-        taps.print_time("Created endpoint objects.", color)
+        logger.info("Created endpoint objects.")
 
         if args.secure or args.trust_ca or args.local_identity:
             # Use TLS
@@ -141,7 +141,7 @@ async def main(self, args):
                 sp.add_trust_ca(args.trust_ca)
             if args.local_identity:
                 sp.add_identity(args.local_identity)
-            taps.print_time("Created SecurityParameters.", color)
+            logger.info("Created SecurityParameters.")
 
         # Create transportProperties Object and set properties
         # Does nothing yet
@@ -160,13 +160,13 @@ async def main(self, args):
         self.preconnection.on_initiate_error(self.handle_initiate_error)
         self.preconnection.on_ready(self.handle_ready)
         # Set the framer
-        framer = testFramer()
+        framer = TestFramer()
         self.preconnection.add_framer(framer)
-        taps.print_time("Created preconnection object and set cbs.", color)
+        logger.info("Created preconnection object and set cbs.")
         # Initiate the connection
         self.connection = await self.preconnection.initiate()
         # msgref = await self.connection.send_message("Hello\n")
-        taps.print_time("Called initiate, connection object created.", color)
+        logger.info("Called initiate, connection object created.")
 
 
 if __name__ == "__main__":

pytaps/__init__.py

@@ -6,4 +6,4 @@
 from .preconnection import Preconnection
 from .securityParameters import SecurityParameters
 from .transportProperties import TransportProperties, PreferenceLevel
-from .utility import print_time, ConnectionState
+from .utility import print_time, ConnectionState, setup_logger