update formatting of code

Author: jryannel

Taskfile.yml

@@ -0,0 +1,12 @@
+version: 3
+
+tasks:
+  install:
+    cmds:
+      - pip install black
+  format:
+    cmds:
+      - black .
+  test:
+    cmds:
+      - pytest

demo_server.py

@@ -17,7 +17,7 @@ class Counter:
     def increment(self):
         self.count += 1
         # notify all registered clients
-        RemoteNode.notify_property_change('demo.Counter/count', self.count)
+        RemoteNode.notify_property_change("demo.Counter/count", self.count)
 
 
 class CounterAdapter(IObjectSource):
@@ -30,7 +30,7 @@ def __init__(self, impl):
 
     def olink_object_name(self):
         # name this source is registered under
-        return 'demo.Counter'
+        return "demo.Counter"
 
     def olink_invoke(self, name: str, args: list[Any]) -> Any:
         # called on incoming invoke message
@@ -48,7 +48,7 @@ def olink_linked(self, name: str, node: "RemoteNode"):
         self.impl._node = node
 
     def olink_collect_properties(self) -> object:
-        return {k: getattr(self.impl, k) for k in ['count']}
+        return {k: getattr(self.impl, k) for k in ["count"]}
 
 
 counter = Counter()
@@ -61,26 +61,27 @@ class RemoteEndpoint(WebSocketEndpoint):
     queue = Queue()
 
     async def sender(self, ws):
-        print('start sender')
+        print("start sender")
         while True:
-            print('001')
+            print("001")
             msg = await self.queue.get()
-            print('send', msg)
+            print("send", msg)
             await ws.send_text(msg)
             self.queue.task_done()
 
     async def on_connect(self, ws: WebSocket):
-        print('on_connect')
+        print("on_connect")
         asyncio.create_task(self.sender(ws))
 
         def writer(msg: str):
-            print('writer', msg)
+            print("writer", msg)
             self.queue.put_nowait(msg)
+
         self.node.on_write(writer)
         await super().on_connect(ws)
 
     async def on_receive(self, ws: WebSocket, data: Any) -> None:
-        print('on_receive', data)
+        print("on_receive", data)
         self.node.handle_message(data)
 
     async def on_disconnect(self, websocket: WebSocket, close_code: int) -> None:
@@ -89,8 +90,6 @@ async def on_disconnect(self, websocket: WebSocket, close_code: int) -> None:
         await self.queue.join()
 
 
-routes = [
-    WebSocketRoute("/ws", RemoteEndpoint)
-]
+routes = [WebSocketRoute("/ws", RemoteEndpoint)]
 
 app = Starlette(routes=routes)

examples/app.py

@@ -14,37 +14,37 @@ class CounterSink(IObjectSink):
     def __init__(self):
         # register sink with client node
         self.client = ClientNode.register_sink(self)
-        print('client', self.client)
+        print("client", self.client)
 
     def increment(self):
         # remote call the increment method
         if self.client:
-            self.client.invoke_remote('demo.Counter/increment', [], None)
+            self.client.invoke_remote("demo.Counter/increment", [], None)
 
     def olink_object_name(self):
         # return the name of the sink
-        return 'demo.Counter'
+        return "demo.Counter"
 
     def olink_on_signal(self, name: str, args: list[Any]):
         # handle the incoming signal from the remote source
         path = Name.path_from_name(name)
-        print('on signal: %s: %s' % (path, args))
+        print("on signal: %s: %s" % (path, args))
 
     def olink_on_property_changed(self, name: str, value: Any) -> None:
         # handle the property change from the remote source
         path = Name.path_from_name(name)
-        print('on property changed: %s: %s' % (path, value))
+        print("on property changed: %s: %s" % (path, value))
 
     def olink_on_init(self, name: str, props: object, node: ClientNode):
         # handle the initialization of the sink,
         # called when the sink is linked to remote source
-        print('on init: %s: %s' % (name, props))
+        print("on init: %s: %s" % (name, props))
         self.client = node
 
     def olink_on_release(self):
         # handle the release of the sink,
         # called when the sink is unlinked from remote source
-        print('on release')
+        print("on release")
 
 
 class ClientWebsocketAdapter:
@@ -59,7 +59,7 @@ def __init__(self, node):
 
     def writer(self, data):
         # don't send directly, first write to queue
-        print('write to queue')
+        print("write to queue")
         self.queue.put_nowait(data)
 
     async def _reader(self, ws):
@@ -86,20 +86,20 @@ async def connect(self, address: str):
                 await asyncio.gather(sender_task, reader_task)
                 await self.queue.join()
             except Exception as e:
-                print('exception while connecting: ', e)
+                print("exception while connecting: ", e)
 
 
-address = 'ws://localhost:8282/ws'
+address = "ws://localhost:8282/ws"
 # create a client node for ObjectLink registry and protocol
 node = ClientNode()
 # link the node to the service name
-node.link_node('demo.Counter')
+node.link_node("demo.Counter")
 
 # create a ws client which handles the ws adapter
 client = ClientWebsocketAdapter(node)
 
 counter = CounterSink()
-node.link_remote('demo.Counter')
+node.link_remote("demo.Counter")
 counter.increment()
 
 

examples/server.py

@@ -16,7 +16,7 @@ class CounterService:
 
     def increment(self):
         self.count += 1
-        self._node.notify_property_change('demo.Counter/count', self.count)
+        self._node.notify_property_change("demo.Counter/count", self.count)
 
 
 class CounterWebsocketAdapter(IObjectSource):
@@ -30,7 +30,7 @@ def __init__(self, impl):
 
     def olink_object_name(self):
         # return service name
-        return 'demo.Counter'
+        return "demo.Counter"
 
     def olink_invoke(self, name: str, args: list[Any]) -> Any:
         # handle the remote call from client node
@@ -42,7 +42,7 @@ def olink_invoke(self, name: str, args: list[Any]) -> Any:
             result = func(**args)
         except Exception as e:
             # need to have proper exception handling here
-            print('error: %s' % e)
+            print("error: %s" % e)
             result = None
         # results will be send back to calling client node
         return result
@@ -58,7 +58,7 @@ def olink_linked(self, name: str, node: "RemoteNode"):
 
     def olink_collect_properties(self) -> object:
         # collect properties from implementation to send back to client node initially
-        return {k: getattr(self.impl, k) for k in ['count']}
+        return {k: getattr(self.impl, k) for k in ["count"]}
 
 
 # create the service implementation
@@ -77,31 +77,32 @@ class RemoteEndpoint(WebSocketEndpoint):
 
     async def sender(self, ws):
         # sender coroutine, messages from queue are send to client
-        print('start sender')
+        print("start sender")
         while True:
             msg = await self.queue.get()
-            print('send', msg)
+            print("send", msg)
             await ws.send_text(msg)
             self.queue.task_done()
 
     async def on_connect(self, ws: WebSocket):
         # handle a socket connection
-        print('on_connect')
+        print("on_connect")
         # register a sender to the connection
         asyncio.create_task(self.sender(ws))
 
         # a writer function to queue messages
         def writer(msg: str):
-            print('write to queue:', msg)
+            print("write to queue:", msg)
             self.queue.put_nowait(msg)
+
         # register the writer function to the node
         self.node.on_write(writer)
         # call the super connection handler
         await super().on_connect(ws)
 
     async def on_receive(self, ws: WebSocket, data: Any) -> None:
         # handle a message from a client socket
-        print('on_receive', data)
+        print("on_receive", data)
         self.node.handle_message(data)
 
     async def on_disconnect(self, websocket: WebSocket, close_code: int) -> None:
@@ -114,9 +115,7 @@ async def on_disconnect(self, websocket: WebSocket, close_code: int) -> None:
 
 
 # see https://www.starlette.io/routing/
-routes = [
-    WebSocketRoute("/ws", RemoteEndpoint)
-]
+routes = [WebSocketRoute("/ws", RemoteEndpoint)]
 
 
 # call with `uvicorn server:app --port 8282`

src/olink/core/protocol.py

@@ -124,7 +124,6 @@ def handle_message(self, msg: list[Any]) -> bool:
             _, msgType, id, error = msg
             self.listener.handle_error(msgType, id, error)
         else:
-            self.emit_log(LogLevel.DEBUG,
-                          f"not supported message type: {msgType}")
+            self.emit_log(LogLevel.DEBUG, f"not supported message type: {msgType}")
             return False
         return True

src/olink/core/types.py

@@ -5,22 +5,22 @@
 
 
 class MsgType(IntEnum):
-    LINK = 10,
-    INIT = 11,
-    UNLINK = 12,
-    SET_PROPERTY = 20,
-    PROPERTY_CHANGE = 21,
-    INVOKE = 30,
-    INVOKE_REPLY = 31,
-    SIGNAL = 40,
-    ERROR = 90,
+    LINK = (10,)
+    INIT = (11,)
+    UNLINK = (12,)
+    SET_PROPERTY = (20,)
+    PROPERTY_CHANGE = (21,)
+    INVOKE = (30,)
+    INVOKE_REPLY = (31,)
+    SIGNAL = (40,)
+    ERROR = (90,)
 
 
 class MessageFormat(IntEnum):
-    JSON = 1,
-    BSON = 2,
-    MSGPACK = 3,
-    CBOR = 4,
+    JSON = (1,)
+    BSON = (2,)
+    MSGPACK = (3,)
+    CBOR = (4,)
 
 
 class Name:
@@ -29,22 +29,22 @@ class Name:
     @staticmethod
     def resource_from_name(name: str) -> str:
         # return the resource name from a name
-        return name.split('/')[0]
+        return name.split("/")[0]
 
     @staticmethod
     def path_from_name(name: str) -> str:
         # return the path from a name
-        return name.split('/')[-1]
+        return name.split("/")[-1]
 
     @staticmethod
     def has_path(name: str) -> bool:
         # return true if name has a path
-        return '/' in name
+        return "/" in name
 
     @staticmethod
     def create_name(resource: str, path: str) -> str:
         # create a name from a resource and a path
-        return f'{resource}/{path}'
+        return f"{resource}/{path}"
 
 
 class MessageConverter:
@@ -65,10 +65,10 @@ def to_string(self, data: list[Any]) -> str:
 
 
 class LogLevel:
-    DEBUG = 1,
-    INFO = 2,
-    WARNING = 3,
-    ERROR = 4,
+    DEBUG = (1,)
+    INFO = (2,)
+    WARNING = (3,)
+    ERROR = (4,)
 
 
 WriteLogFunc = Callable[[LogLevel, str], None]

src/olink/mocks/mocksink.py

@@ -2,45 +2,48 @@
 from typing import Any, Optional
 from olink.clientnode import ClientNode, IObjectSink, InvokeReplyArg
 
+
 class MockSink(IObjectSink):
     name: str
     events: list[Any] = []
     node: Optional[ClientNode] = None
     properties: dict[str, Any] = {}
+
     def __init__(self, name: str):
         self.name = name
         self.node = ClientNode.register_sink(self)
 
     def invoke(self, name: str, args: list[Any]):
         if self.node:
+
             def func(arg: InvokeReplyArg):
-                self.events.append({'type': 'invoke-reply', 'name': arg.name, 'value': arg.value})
+                self.events.append(
+                    {"type": "invoke-reply", "name": arg.name, "value": arg.value}
+                )
+
             self.node.invoke_remote(name, args, func)
-    
+
     def olink_object_name(self) -> str:
         return self.name
 
     def olink_on_signal(self, name: str, args: list[Any]) -> None:
-        self.events.append({'type': 'signal', 'name': name, 'args': args})
+        self.events.append({"type": "signal", "name": name, "args": args})
 
     def olink_on_property_changed(self, name: str, value: Any) -> None:
         path = Name.path_from_name(name)
-        self.events.append({ 'type': 'property_change', 'name': name, 'value': value})
+        self.events.append({"type": "property_change", "name": name, "value": value})
         self.properties[path] = value
 
     def olink_on_init(self, name: str, props: object, node: "ClientNode"):
-        self.events.append({'type': 'init', 'name': name, 'props': props})
+        self.events.append({"type": "init", "name": name, "props": props})
         self.node = node
         self.properties = props
 
     def olink_on_release(self) -> None:
-        self.events.append({'type': 'release'})
+        self.events.append({"type": "release"})
         self.node = None
 
     def clear(self):
         self.events = []
         self.properties = {}
         self.node = None
-
-
-