fixing the minor bugs

Author: aditya0yadav

src/dubbo/client.py

@@ -15,11 +15,10 @@
 # limitations under the License.
 
 import threading
-from typing import Optional
+from typing import Optional, List, Type
 
 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
@@ -33,6 +32,7 @@
     SerializingFunction,
 )
 from dubbo.url import URL
+from dubbo.codec import DubboSerializationService
 
 __all__ = ["Client"]
 
@@ -88,21 +88,22 @@ 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,
     ) -> RpcCallable:
         """
         Create RPC callable with the specified type.
         """
+        print("2", params_types)
         # Determine serializers
         if request_serializer and response_deserializer:
             req_ser = request_serializer
             res_deser = response_deserializer
         else:
-            req_ser, res_deser = DubboTransportService.create_serialization_functions(
+            req_ser, res_deser = DubboSerializationService.create_serialization_functions(
                 codec or "json",
                 parameter_types=params_types,
                 return_type=return_type,
@@ -118,7 +119,8 @@ 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:
+        print("1", params_types)
         return self._create_rpc_callable(
             rpc_type=RpcTypes.UNARY.value,
             method_name=method_name,
@@ -127,7 +129,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 +138,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 +147,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/codec/__init__.py

@@ -14,6 +14,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .dubbo_codec import DubboTransportService
+from .dubbo_codec import DubboSerializationService
 
-__all__ = ["DubboTransportService"]
+__all__ = ["DubboSerializationService"]

src/dubbo/codec/dubbo_codec.py

@@ -24,7 +24,7 @@
 
 @dataclass
 class ParameterDescriptor:
-    """Detailed information about a method parameter"""
+    """Information about a method parameter"""
 
     name: str
     annotation: Any
@@ -34,7 +34,7 @@ class ParameterDescriptor:
 
 @dataclass
 class MethodDescriptor:
-    """Complete method descriptor with all necessary information"""
+    """Method descriptor with function details"""
 
     function: Callable
     name: str
@@ -44,13 +44,16 @@ class MethodDescriptor:
 
 
 class DubboSerializationService:
-    """Dubbo serialization service with robust type handling"""
+    """Dubbo serialization service with type handling"""
 
     @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: Optional[list[type]] = None,
+        return_type: Optional[type] = None,
+        **codec_options,
     ):
-        """Create transport codec with enhanced parameter structure"""
+        """Create transport codec"""
 
         try:
             from dubbo.classes import CodecHelper
@@ -67,13 +70,19 @@ def create_transport_codec(
 
     @staticmethod
     def create_encoder_decoder_pair(
-        transport_type: str, parameter_types: list[type] = None, return_type: type = None, **codec_options
+        transport_type: str,
+        parameter_types: Optional[list[type]] = None,
+        return_type: Optional[type] = None,
+        **codec_options,
     ) -> tuple[Any, Any]:
-        """Create separate encoder and decoder instances"""
+        """Create encoder and decoder instances"""
 
         try:
             codec_instance = DubboSerializationService.create_transport_codec(
-                transport_type=transport_type, parameter_types=parameter_types, return_type=return_type, **codec_options
+                transport_type=transport_type,
+                parameter_types=parameter_types,
+                return_type=return_type,
+                **codec_options,
             )
 
             encoder = codec_instance.get_encoder()
@@ -90,13 +99,19 @@ def create_encoder_decoder_pair(
 
     @staticmethod
     def create_serialization_functions(
-        transport_type: str, parameter_types: list[type] = None, return_type: type = None, **codec_options
+        transport_type: str,
+        parameter_types: Optional[list[type]] = None,
+        return_type: Optional[type] = None,
+        **codec_options,
     ) -> tuple[Callable, Callable]:
-        """Create serializer and deserializer functions for RPC (backward compatibility)"""
+        """Create serializer and deserializer functions"""
 
         try:
             parameter_encoder, return_decoder = DubboSerializationService.create_encoder_decoder_pair(
-                transport_type=transport_type, parameter_types=parameter_types, return_type=return_type, **codec_options
+                transport_type=transport_type,
+                parameter_types=parameter_types,
+                return_type=return_type,
+                **codec_options,
             )
 
             def serialize_method_parameters(*args) -> bytes:
@@ -125,17 +140,17 @@ def deserialize_method_return(data: bytes):
     def create_method_descriptor(
         func: Callable,
         method_name: Optional[str] = None,
-        parameter_types: list[type] = None,
-        return_type: type = None,
-        interface: Callable = None,
+        parameter_types: Optional[list[type]] = None,
+        return_type: Optional[type] = None,
+        interface: Optional[Callable[..., Any]] = None,
     ) -> MethodDescriptor:
         """Create a method descriptor from function and configuration"""
 
         if not callable(func):
             raise TypeError("func must be callable")
 
         # Use interface signature if provided, otherwise use func signature
-        target_function = interface if interface else func
+        target_function = interface if interface is not None else func
         name = method_name or target_function.__name__
 
         try:
@@ -166,14 +181,17 @@ def create_method_descriptor(
 
             parameters.append(
                 ParameterDescriptor(
-                    name=param_name, annotation=param_type, is_required=is_required, default_value=default_value
+                    name=param_name,
+                    annotation=param_type,
+                    is_required=is_required,
+                    default_value=default_value,
                 )
             )
 
             param_index += 1
 
         # Resolve return type
-        if return_type:
+        if return_type is not None:
             resolved_return_type = return_type
         elif sig.return_annotation != inspect.Signature.empty:
             resolved_return_type = sig.return_annotation

src/dubbo/codec/json_codec/json_transport_base.py

@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Callable, Protocol
+from typing import Any, Callable, Protocol, Optional
 
 
 class JsonSerializerPlugin(Protocol):
@@ -36,18 +36,18 @@ class SimpleRegistry:
 
     def __init__(self):
         # Simple dict mapping: type -> handler function
-        self.type_handlers: dict[type, Callable] = {}
+        self.type_handlers: dict[type, Callable[..., Any]] = {}
         self.plugins: list[TypeHandlerPlugin] = []
 
-    def register_type_handler(self, obj_type: type, handler: Callable):
+    def register_type_handler(self, obj_type: type, handler: Callable[..., Any]) -> None:
         """Register a simple type handler function"""
         self.type_handlers[obj_type] = handler
 
-    def register_plugin(self, plugin: TypeHandlerPlugin):
+    def register_plugin(self, plugin: TypeHandlerPlugin) -> None:
         """Register a plugin"""
         self.plugins.append(plugin)
 
-    def get_handler(self, obj: Any) -> Callable:
+    def get_handler(self, obj: Any) -> Optional[Callable[..., Any]]:
         """Get handler for object - check dict first, then plugins"""
         obj_type = type(obj)
         if obj_type in self.type_handlers:

src/dubbo/codec/json_codec/json_transport_codec.py

@@ -23,10 +23,11 @@
 from pathlib import Path
 from typing import Any, Union
 from uuid import UUID
+from typing import Optional
 
 
 class StandardJsonPlugin:
-    """Standard library JSON plugin"""
+    """Standard library JSON codec"""
 
     def encode(self, obj: Any) -> bytes:
         return json.dumps(obj, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
@@ -39,7 +40,7 @@ def can_handle(self, obj: Any) -> bool:
 
 
 class OrJsonPlugin:
-    """orjson plugin independent implementation"""
+    """orjson Codec independent implementation"""
 
     def __init__(self):
         try:
@@ -131,12 +132,12 @@ def _default_handler(self, obj):
 
 
 class DateTimeHandler:
-    """DateTime handler - implements TypeHandlerPlugin protocol"""
+    """DateTime handler - implements TypeHandler Codec"""
 
     def can_serialize_type(self, obj: Any, obj_type: type) -> bool:
         return isinstance(obj, (datetime, date, time))
 
-    def serialize_to_dict(self, obj: Union[datetime, date, time]) -> dict[str, str]:
+    def serialize_to_dict(self, obj: Union[datetime, date, time]) -> dict[str, str | None]:
         if isinstance(obj, datetime):
             return {"__datetime__": obj.isoformat(), "__timezone__": str(obj.tzinfo) if obj.tzinfo else None}
         elif isinstance(obj, date):
@@ -193,7 +194,7 @@ def serialize_to_dict(self, obj: Union[UUID, Path]) -> dict[str, str]:
 
 
 class PydanticHandler:
-    """Separate Pydantic plugin with enhanced features"""
+    """Pydantic codec for handling advance serialization"""
 
     def __init__(self):
         try:
@@ -219,9 +220,9 @@ def serialize_to_dict(self, obj) -> dict[str, Any]:
             "__model_data__": obj.dict(),
         }
 
-    def create_parameter_model(self, parameter_types: list[type]):
+    def create_parameter_model(self, parameter_types: Optional[list[type]] = None):
         """Enhanced parameter handling for both positional and keyword args"""
-        if not self.available:
+        if not self.available or parameter_types is None:
             return None
 
         model_fields = {}