fixed with changes

Author: aditya0yadav

src/dubbo/proxy/handlers.py

@@ -1,19 +1,3 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
 import inspect
 from typing import Callable, Optional, List, Type, Any, get_type_hints
 from dubbo.classes import MethodDescriptor
@@ -27,33 +11,75 @@
 __all__ = ["RpcMethodHandler", "RpcServiceHandler"]
 
 
+class RpcMethodConfigurationError(Exception):
+    """
+    Raised when RPC method is configured incorrectly.
+    """
+    pass
+
+
 class RpcMethodHandler:
+    """
+    Rpc method handler that wraps metadata and serialization logic for a callable.
+    """
+
     __slots__ = ["_method_descriptor"]
 
     def __init__(self, method_descriptor: MethodDescriptor):
+        """
+        Initialize the RpcMethodHandler
+        :param method_descriptor: the method descriptor.
+        :type method_descriptor: MethodDescriptor
+        """
         self._method_descriptor = method_descriptor
 
     @property
     def method_descriptor(self) -> MethodDescriptor:
+        """
+        Get the method descriptor
+        :return: the method descriptor
+        :rtype: MethodDescriptor
+        """
         return self._method_descriptor
 
     @staticmethod
     def get_codec(**kwargs) -> tuple:
+        """
+        Get the serialization and deserialization functions based on codec
+        :param kwargs: codec settings like transport_type, parameter_types, return_type
+        :return: serializer and deserializer functions
+        :rtype: Tuple[SerializingFunction, DeserializingFunction]
+        """
         return DubboTransportService.create_serialization_functions(**kwargs)
 
     @classmethod
     def _infer_types_from_method(cls, method: Callable) -> tuple:
+        """
+        Infer method name, parameter types, and return type from a callable
+        :param method: the method to analyze
+        :type method: Callable
+        :return: tuple of method name, parameter types, return type
+        :rtype: Tuple[str, List[Type], Type]
+        """
         try:
             type_hints = get_type_hints(method)
             sig = inspect.signature(method)
             method_name = method.__name__
             params = list(sig.parameters.values())
+
             if params and params[0].name == "self":
-                params = params[1:]
+                raise RpcMethodConfigurationError(
+                    f"Method '{method_name}' appears to be an unbound method with 'self' parameter. "
+                    "RPC methods should be bound methods (e.g., instance.method) or standalone functions. "
+                    "If you're registering a class method, ensure you pass a bound method: "
+                    "RpcMethodHandler.unary(instance.method) not RpcMethodHandler.unary(Class.method)"
+                )
 
             params_types = [type_hints.get(p.name, Any) for p in params]
             return_type = type_hints.get("return", Any)
             return method_name, params_types, return_type
+        except RpcMethodConfigurationError:
+            raise
         except Exception:
             return method.__name__, [Any], Any
 
@@ -70,6 +96,20 @@ def _create_method_descriptor(
         return_decoder: Optional[SerializingFunction] = None,
         **kwargs,
     ) -> MethodDescriptor:
+        """
+        Create a MethodDescriptor with serialization configuration
+        :param method: the actual function/method
+        :param method_name: RPC method name
+        :param params_types: parameter type hints
+        :param return_type: return type hint
+        :param rpc_type: type of RPC (unary, stream, etc.)
+        :param codec: serialization codec (json, pb, etc.)
+        :param param_encoder: deserialization function
+        :param return_decoder: serialization function
+        :param kwargs: additional codec args
+        :return: MethodDescriptor instance
+        :rtype: MethodDescriptor
+        """
         if param_encoder is None or return_decoder is None:
             codec_kwargs = {
                 "transport_type": codec or "json",
@@ -101,6 +141,18 @@ def unary(
         response_serializer: Optional[SerializingFunction] = None,
         **kwargs,
     ) -> "RpcMethodHandler":
+        """
+        Register a unary RPC method handler
+        :param method: the callable function
+        :param method_name: RPC method name
+        :param params_types: input types
+        :param return_type: output type
+        :param codec: serialization codec
+        :param request_deserializer: custom deserializer
+        :param response_serializer: custom serializer
+        :return: RpcMethodHandler instance
+        :rtype: RpcMethodHandler
+        """
         inferred_name, inferred_param_types, inferred_return_type = cls._infer_types_from_method(method)
         resolved_method_name = method_name or inferred_name
         resolved_param_types = params_types or inferred_param_types
@@ -133,6 +185,18 @@ def client_stream(
         response_serializer: Optional[SerializingFunction] = None,
         **kwargs,
     ) -> "RpcMethodHandler":
+        """
+        Register a client-streaming RPC method handler
+        :param method: the callable function
+        :param method_name: RPC method name
+        :param params_types: input types
+        :param return_type: output type
+        :param codec: serialization codec
+        :param request_deserializer: custom deserializer
+        :param response_serializer: custom serializer
+        :return: RpcMethodHandler instance
+        :rtype: RpcMethodHandler
+        """
         inferred_name, inferred_param_types, inferred_return_type = cls._infer_types_from_method(method)
         resolved_method_name = method_name or inferred_name
         resolved_param_types = params_types or inferred_param_types
@@ -165,6 +229,18 @@ def server_stream(
         response_serializer: Optional[SerializingFunction] = None,
         **kwargs,
     ) -> "RpcMethodHandler":
+        """
+        Register a server-streaming RPC method handler
+        :param method: the callable function
+        :param method_name: RPC method name
+        :param params_types: input types
+        :param return_type: output type
+        :param codec: serialization codec
+        :param request_deserializer: custom deserializer
+        :param response_serializer: custom serializer
+        :return: RpcMethodHandler instance
+        :rtype: RpcMethodHandler
+        """
         inferred_name, inferred_param_types, inferred_return_type = cls._infer_types_from_method(method)
         resolved_method_name = method_name or inferred_name
         resolved_param_types = params_types or inferred_param_types
@@ -197,6 +273,18 @@ def bi_stream(
         response_serializer: Optional[SerializingFunction] = None,
         **kwargs,
     ) -> "RpcMethodHandler":
+        """
+        Register a bidirectional streaming RPC method handler
+        :param method: the callable function
+        :param method_name: RPC method name
+        :param params_types: input types
+        :param return_type: output type
+        :param codec: serialization codec
+        :param request_deserializer: custom deserializer
+        :param response_serializer: custom serializer
+        :return: RpcMethodHandler instance
+        :rtype: RpcMethodHandler
+        """
         inferred_name, inferred_param_types, inferred_return_type = cls._infer_types_from_method(method)
         resolved_method_name = method_name or inferred_name
         resolved_param_types = params_types or inferred_param_types
@@ -219,9 +307,20 @@ def bi_stream(
 
 
 class RpcServiceHandler:
+    """
+    Rpc service handler that maps method names to their corresponding RpcMethodHandler.
+    """
+
     __slots__ = ["_service_name", "_method_handlers"]
 
-    def __init__(self, service_name: str, method_handlers: list[RpcMethodHandler]):
+    def __init__(self, service_name: str, method_handlers: List[RpcMethodHandler]):
+        """
+        Initialize the RpcServiceHandler
+        :param service_name: the name of the service.
+        :type service_name: str
+        :param method_handlers: list of RpcMethodHandler instances
+        :type method_handlers: List[RpcMethodHandler]
+        """
         self._service_name = service_name
         self._method_handlers: dict[str, RpcMethodHandler] = {}
 
@@ -231,8 +330,18 @@ def __init__(self, service_name: str, method_handlers: list[RpcMethodHandler]):
 
     @property
     def service_name(self) -> str:
+        """
+        Get the service name
+        :return: the service name
+        :rtype: str
+        """
         return self._service_name
 
     @property
     def method_handlers(self) -> dict[str, RpcMethodHandler]:
-        return self._method_handlers
+        """
+        Get the registered RPC method handlers
+        :return: mapping of method names to handlers
+        :rtype: Dict[str, RpcMethodHandler]
+        """
+        return self._method_handlers

src/dubbo/server.py

@@ -81,4 +81,4 @@ def start(self):
 
             self._protocol.export(self._url)
 
-            self._exported = True
+            self._exported = True