changing the type for organisation requirement..

Author: aditya0yadav

samples/llm/chat_pb2.py

@@ -15,12 +15,12 @@
 # limitations under the License.
 from time import sleep
 
+import chat_pb2
 from lmdeploy import GenerationConfig, TurbomindEngineConfig, pipeline
 
 from dubbo import Dubbo
 from dubbo.configs import RegistryConfig, ServiceConfig
 from dubbo.proxy.handlers import RpcMethodHandler, RpcServiceHandler
-import chat_pb2
 
 # the path of a model. It could be one of the following options:
 # 1. A local directory path of a turbomind model

samples/llm/main.py

@@ -16,8 +16,9 @@
 
 import abc
 import threading
-from typing import Any, Callable, Optional, Union, Type
 from abc import ABC, abstractmethod
+from typing import Any, Callable, Optional, Union
+
 from dubbo.types import DeserializingFunction, RpcType, RpcTypes, SerializingFunction
 
 __all__ = [
@@ -248,7 +249,7 @@ class ReadWriteStream(ReadStream, WriteStream, abc.ABC):
 
 
 class Codec(ABC):
-    def __init__(self, model_type: Optional[Type[Any]] = None, **kwargs):
+    def __init__(self, model_type: Optional[type[Any]] = None, **kwargs):
         self.model_type = model_type
 
     @abstractmethod

src/dubbo/classes.py

@@ -15,10 +15,11 @@
 # limitations under the License.
 
 import threading
-from typing import Optional, List, Type
+from typing import Optional
 
 from dubbo.bootstrap import Dubbo
 from dubbo.classes import MethodDescriptor
+from dubbo.codec import DubboTransportService
 from dubbo.configs import ReferenceConfig
 from dubbo.constants import common_constants
 from dubbo.extension import extensionLoader
@@ -32,7 +33,6 @@
     SerializingFunction,
 )
 from dubbo.url import URL
-from dubbo.codec import DubboTransportService
 
 __all__ = ["Client"]
 
@@ -88,8 +88,8 @@ def _create_rpc_callable(
         self,
         rpc_type: str,
         method_name: str,
-        params_types: List[Type],
-        return_type: Type,
+        params_types: list[type],
+        return_type: type,
         codec: Optional[str] = None,
         request_serializer: Optional[SerializingFunction] = None,
         response_deserializer: Optional[DeserializingFunction] = None,
@@ -118,7 +118,7 @@ def _create_rpc_callable(
 
         return self._callable(descriptor)
 
-    def unary(self, method_name: str, params_types: List[Type], return_type: Type, **kwargs) -> RpcCallable:
+    def unary(self, method_name: str, params_types: list[type], return_type: type, **kwargs) -> RpcCallable:
         return self._create_rpc_callable(
             rpc_type=RpcTypes.UNARY.value,
             method_name=method_name,
@@ -127,7 +127,7 @@ def unary(self, method_name: str, params_types: List[Type], return_type: Type, *
             **kwargs,
         )
 
-    def client_stream(self, method_name: str, params_types: List[Type], return_type: Type, **kwargs) -> RpcCallable:
+    def client_stream(self, method_name: str, params_types: list[type], return_type: type, **kwargs) -> RpcCallable:
         return self._create_rpc_callable(
             rpc_type=RpcTypes.CLIENT_STREAM.value,
             method_name=method_name,
@@ -136,7 +136,7 @@ def client_stream(self, method_name: str, params_types: List[Type], return_type:
             **kwargs,
         )
 
-    def server_stream(self, method_name: str, params_types: List[Type], return_type: Type, **kwargs) -> RpcCallable:
+    def server_stream(self, method_name: str, params_types: list[type], return_type: type, **kwargs) -> RpcCallable:
         return self._create_rpc_callable(
             rpc_type=RpcTypes.SERVER_STREAM.value,
             method_name=method_name,
@@ -145,7 +145,7 @@ def server_stream(self, method_name: str, params_types: List[Type], return_type:
             **kwargs,
         )
 
-    def bi_stream(self, method_name: str, params_types: List[Type], return_type: Type, **kwargs) -> RpcCallable:
+    def bi_stream(self, method_name: str, params_types: list[type], return_type: type, **kwargs) -> RpcCallable:
         return self._create_rpc_callable(
             rpc_type=RpcTypes.BI_STREAM.value,
             method_name=method_name,

src/dubbo/client.py

@@ -14,10 +14,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Type, Optional, Callable, List, Dict, Tuple
-from dataclasses import dataclass
 import inspect
 import logging
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -38,7 +38,7 @@ class MethodDescriptor:
 
     function: Callable
     name: str
-    parameters: List[ParameterDescriptor]
+    parameters: list[ParameterDescriptor]
     return_parameter: ParameterDescriptor
     documentation: Optional[str] = None
 
@@ -48,27 +48,27 @@ class DubboSerializationService:
 
     @staticmethod
     def create_transport_codec(
-        transport_type: str = "json", parameter_types: List[Type] = None, return_type: Type = None, **codec_options
+        transport_type: str = "json", parameter_types: list[type] = None, return_type: type = None, **codec_options
     ):
         """Create transport codec with enhanced parameter structure"""
 
         try:
-            from dubbo.extension.extension_loader import ExtensionLoader
             from dubbo.classes import CodecHelper
+            from dubbo.extension.extension_loader import ExtensionLoader
 
             codec_class = ExtensionLoader().get_extension(CodecHelper.get_class(), transport_type)
             return codec_class(parameter_types=parameter_types or [], return_type=return_type, **codec_options)
         except ImportError as e:
-            logger.error(f"Failed to import required modules: {e}")
+            logger.error("Failed to import required modules: %s", e)
             raise
         except Exception as e:
-            logger.error(f"Failed to create transport codec: {e}")
+            logger.error("Failed to create transport codec: %s", e)
             raise
 
     @staticmethod
     def create_encoder_decoder_pair(
-        transport_type: str, parameter_types: List[Type] = None, return_type: Type = None, **codec_options
-    ) -> Tuple[Any, Any]:
+        transport_type: str, parameter_types: list[type] = None, return_type: type = None, **codec_options
+    ) -> tuple[Any, Any]:
         """Create separate encoder and decoder instances"""
 
         try:
@@ -85,13 +85,13 @@ def create_encoder_decoder_pair(
             return encoder, decoder
 
         except Exception as e:
-            logger.error(f"Failed to create encoder/decoder pair: {e}")
+            logger.error("Failed to create encoder/decoder pair: %s", e)
             raise
 
     @staticmethod
     def create_serialization_functions(
-        transport_type: str, parameter_types: List[Type] = None, return_type: Type = None, **codec_options
-    ) -> Tuple[Callable, Callable]:
+        transport_type: str, parameter_types: list[type] = None, return_type: type = None, **codec_options
+    ) -> tuple[Callable, Callable]:
         """Create serializer and deserializer functions for RPC (backward compatibility)"""
 
         try:
@@ -103,7 +103,7 @@ def serialize_method_parameters(*args) -> bytes:
                 try:
                     return parameter_encoder.encode(args)
                 except Exception as e:
-                    logger.error(f"Failed to serialize parameters: {e}")
+                    logger.error("Failed to serialize parameters: %s", e)
                     raise
 
             def deserialize_method_return(data: bytes):
@@ -112,21 +112,21 @@ def deserialize_method_return(data: bytes):
                 try:
                     return return_decoder.decode(data)
                 except Exception as e:
-                    logger.error(f"Failed to deserialize return value: {e}")
+                    logger.error("Failed to deserialize return value: %s", e)
                     raise
 
             return serialize_method_parameters, deserialize_method_return
 
         except Exception as e:
-            logger.error(f"Failed to create serialization functions: {e}")
+            logger.error("Failed to create serialization functions: %s", e)
             raise
 
     @staticmethod
     def create_method_descriptor(
         func: Callable,
         method_name: Optional[str] = None,
-        parameter_types: List[Type] = None,
-        return_type: Type = None,
+        parameter_types: list[type] = None,
+        return_type: type = None,
         interface: Callable = None,
     ) -> MethodDescriptor:
         """Create a method descriptor from function and configuration"""
@@ -141,7 +141,7 @@ def create_method_descriptor(
         try:
             sig = inspect.signature(target_function)
         except ValueError as e:
-            logger.error(f"Cannot inspect signature of {target_function}: {e}")
+            logger.error("Cannot inspect signature of %s: %s", target_function, e)
             raise
 
         parameters = []

src/dubbo/codec/dubbo_codec.py

@@ -14,6 +14,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .json_codec_handler import JsonTransportCodec, JsonTransportEncoder, JsonTransportDecoder
+from .json_codec_handler import JsonTransportCodec, JsonTransportDecoder, JsonTransportEncoder
 
 __all__ = ["JsonTransportCodec", "JsonTransportDecoder", "JsonTransportEncoder"]