removing some async part

Author: valentin-gauthier-geosiris

etpproto/connection.py

@@ -7,6 +7,7 @@
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import (
+    Generator,
     AsyncGenerator,
     Callable,
     ClassVar,
@@ -55,12 +56,12 @@
 
 
 class Protocol:
-    async def handle_message(
+    def handle_message(
         self,
         etp_object: object,
         msg_header: MessageHeader,
         client_info: Union[None, ClientInfo] = None,
-    ) -> AsyncGenerator[Optional[Message], None]:
+    ) -> Generator[Optional[Message], None]:
         yield NotSupportedError().to_etp_message(
             correlation_id=msg_header.message_id
         )
@@ -385,9 +386,9 @@ async def _handle_message_generator(
                 msg_id=self.consume_msg_id()
             )
 
-    async def send_msg_and_error_generator(
+    def send_msg_and_error_generator(
         self, msg: Message, err_msg: Message
-    ) -> AsyncGenerator[Tuple[int, bytes], None]:
+    ) -> Generator[Tuple[int, bytes], None]:
         current_msg_id = self.consume_msg_id()
 
         if msg:
@@ -398,7 +399,7 @@ async def send_msg_and_error_generator(
             # err_msg.header.message_id = self.message_id
             # self.message_id += 2
 
-            async for msg_part in msg.encode_message_generator(
+            for msg_part in msg.encode_message_generator(
                 self.client_info.getCapability(
                     "MaxWebSocketMessagePayloadSize"
                 ),
@@ -407,7 +408,7 @@ async def send_msg_and_error_generator(
                 yield (current_msg_id, msg_part)
 
             if err_msg:
-                async for msg_part in err_msg.encode_message_generator(
+                for msg_part in err_msg.encode_message_generator(
                     self.client_info.getCapability(
                         "MaxWebSocketMessagePayloadSize"
                     ),
@@ -417,7 +418,7 @@ async def send_msg_and_error_generator(
 
         elif err_msg:
             # logging.debug(f"{self.client_info.ip} : Encoding error")
-            async for msg_part in err_msg.encode_message_generator(
+            for msg_part in err_msg.encode_message_generator(
                 self.client_info.getCapability(
                     "MaxWebSocketMessagePayloadSize"
                 ),
@@ -439,7 +440,7 @@ async def handle_bytes_generator(
 
         async for msg in self._handle_message_generator(etp_input_msg):
             if msg is not None:
-                async for msg_part in msg.encode_message_generator(
+                for msg_part in msg.encode_message_generator(
                     self.client_info.getCapability(
                         "MaxWebSocketMessagePayloadSize"
                     ),

etpproto/messages.py

@@ -13,7 +13,7 @@
 from enum import IntFlag
 from io import BytesIO
 from math import ceil
-from typing import AsyncGenerator, Dict, List, Optional, Tuple, Any, Union
+from typing import Generator, Dict, List, Optional, Tuple, Any, Union
 
 import etptypes.energistics.etp.v12.datatypes.message_header as mh
 from etptypes import ETPModel, avro_schema
@@ -90,9 +90,9 @@ def encode_message(self) -> bytes:
     #       - Sinon, on si contient un BLOB, on essaie de le couper en plusieurs messages
     #       - Sinon on envoie un message d'erreur
     # max_bytes_per_msg : negative number for infinite size
-    async def encode_message_generator(  # noqa
+    def encode_message_generator(  # noqa
         self, max_bytes_per_msg, connection
-    ) -> AsyncGenerator[bytes, None]:
+    ) -> Generator[bytes, None]:
         # si requete on met le correlation_id sur le l'id du premier message
         # si self a un correlation_id alors c'est que ce n'était pas le premier
         correlation_id = (
@@ -181,11 +181,11 @@ async def encode_message_generator(  # noqa
                         msg2.add_header_flag(MessageFlags.MULTIPART)
 
                         msg1.set_final_msg(False)
-                        async for part in msg1.encode_message_generator(
+                        for part in msg1.encode_message_generator(
                             max_bytes_per_msg, connection
                         ):
                             yield part
-                        async for part in msg2.encode_message_generator(
+                        for part in msg2.encode_message_generator(
                             max_bytes_per_msg, connection
                         ):
                             yield part
@@ -195,7 +195,7 @@ async def encode_message_generator(  # noqa
                             and len(values) > 0
                             and self.is_chunkable()
                         ):
-                            async for part in _encode_message_generator_chunk(
+                            for part in _encode_message_generator_chunk(
                                 chunkable_msg=self,
                                 encoded_msg_size=body_size,
                                 max_bytes_per_msg=max_bytes_per_msg,
@@ -220,7 +220,7 @@ async def encode_message_generator(  # noqa
             )
             if msg_err is not None:
                 msg_err.set_final_msg(True)
-                async for part in msg_err.encode_message_generator(
+                for part in msg_err.encode_message_generator(
                     -1, connection
                 ):
                     yield part
@@ -491,12 +491,12 @@ def decode_binary_message(
 
 
 # When calling thins function we are supposed to have only one entry in the data_objects map/list
-async def _encode_message_generator_chunk(
+def _encode_message_generator_chunk(
     chunkable_msg: Message,
     encoded_msg_size: int,
     max_bytes_per_msg: int,
     connection,
-) -> AsyncGenerator[bytes, None]:
+) -> Generator[bytes, None]:
     from etpproto.error import InternalError
 
     secure_size = 50  # TODO : ameliorer pour que le chunk fasse vraiment la taille max d'un message (il faudrait connaitre la taille de ce qui n'est pas binaire dans le chunk message)
@@ -585,7 +585,7 @@ async def _encode_message_generator_chunk(
             # send the message
             chunkable_msg.set_final_msg(False)
             chunkable_msg.add_header_flag(MessageFlags.MULTIPART)
-            async for part in chunkable_msg.encode_message_generator(
+            for part in chunkable_msg.encode_message_generator(
                 max_bytes_per_msg, connection
             ):
                 yield part
@@ -600,7 +600,7 @@ async def _encode_message_generator_chunk(
                     message_flags=MessageFlags.MULTIPART,
                 )
                 if current_chunk_msg is not None:
-                    async for (
+                    for (
                         part
                     ) in current_chunk_msg.encode_message_generator(
                         max_bytes_per_msg, connection
@@ -625,7 +625,7 @@ async def _encode_message_generator_chunk(
                 ),
             )
             if final_chunk_msg is not None:
-                async for part in final_chunk_msg.encode_message_generator(
+                for part in final_chunk_msg.encode_message_generator(
                     max_bytes_per_msg, connection
                 ):
                     yield part

etpproto/protocols/__init__.py

@@ -1,2 +1,19 @@
 # Copyright (c) 2022-2023 Geosiris.
 # SPDX-License-Identifier: Apache-2.0
+
+from .channel_data_frame import ChannelDataFrameHandler
+from .channel_data_load import ChannelDataLoadHandler
+from .channel_streaming import ChannelStreamingHandler
+from .channel_subscribe import ChannelSubscribeHandler
+from .core import CoreHandler
+from .data_array import DataArrayHandler
+from .dataspace import DataspaceHandler
+from .discovery import DiscoveryHandler
+from .growing_object import GrowingObjectHandler
+from .growing_object_query import GrowingObjectQueryHandler
+from .growing_object_notification import GrowingObjectNotificationHandler
+from .store_notification import StoreNotificationHandler
+from .store_query import StoreQueryHandler
+from .store import StoreHandler
+from .supported_types import SupportedTypesHandler
+from .transaction import TransactionHandler