Add support for concrete methods in interfaces

Author: binyamin555

README.md

@@ -9,6 +9,7 @@ A Python library that provides explicit interface implementations with compile-t
 ## Features
 
 - **Explicit Interface Declarations**: Define clear interface contracts using abstract methods
+- **Concrete Method Support**: Include concrete methods in interfaces with default implementations
 - **Flexible Implementation**: Allow partial implementations by default, enforce completeness with `concrete=True`
 - **Compile-time Safety**: Catch implementation errors at class definition time, not runtime
 - **Multiple Interface Support**: Implement multiple interfaces in a single class
@@ -109,6 +110,42 @@ repository_interface.save({"name": "example"})
 repository_interface.load("123")
 ```
 
+### Concrete Methods in Interfaces
+
+Interfaces can include concrete (non-abstract) methods that provide default implementations. These methods can be accessed directly from implementing classes without explicit implementation:
+
+```python
+class IService(Interface):
+    @abstractmethod
+    def process(self, data: str) -> str:
+        ...
+    
+    def log(self, message: str) -> None:
+        """Concrete method with default implementation."""
+        print(f"[LOG] {message}")
+    
+    @classmethod
+    def get_version(cls) -> str:
+        """Concrete class method."""
+        return "1.0.0"
+
+class MyService(IService):
+    @implements(IService.process)
+    def process_data(self, data: str) -> str:
+        return f"Processed: {data}"
+
+service = MyService()
+
+# Access concrete methods directly
+service.log("Starting process")          # Works directly
+service.get_version()                    # Works directly
+
+# Also accessible through interface casting
+interface = service.as_interface(IService)
+interface.log("Through interface")       # Also works
+interface.get_version()                  # Also works
+```
+
 ### Concrete Classes
 
 By default, partial implementations are allowed at class definition time. To enforce complete implementation:
@@ -302,6 +339,12 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ## Changelog
 
+### 0.1.1
+- **Bug Fix**: Fixed access to concrete (non-abstract) methods when using `as_interface()`
+- Concrete methods in interfaces can now be properly accessed both directly and through interface casting
+- Added comprehensive test coverage for concrete method access patterns
+- Improved documentation with concrete method usage examples
+
 ### 0.1.0
 - Initial release
 - Basic interface and implementation functionality

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "explicit-implementation"
-version = "0.1.0"
+version = "0.1.1"
 description = "A Python library for explicit interface implementations with compile-time safety"
 readme = "README.md"
 authors = [

src/explicit_implementation/interface.py

@@ -1,6 +1,5 @@
 from abc import ABCMeta
-from sys import implementation
-from typing import Callable, Dict, Set, Type, TypeVar
+from typing import Callable, Dict, FrozenSet, Type, TypeVar, cast
 
 
 ImplementationMapping = Dict[Callable, Callable]
@@ -9,7 +8,7 @@
 
 class InterfaceMeta(ABCMeta):
     __explicit__implementations__: Dict[Type['Interface'], ImplementationMapping]
-    __explicit__specifications__: Set[Callable]
+    __explicit__specifications__: FrozenSet[Callable]
 
     def __new__(mcs, name, bases, namespace, *, concrete: bool = False):
         inherited_specifications = []
@@ -108,15 +107,15 @@ def __new__(mcs, name, bases, namespace, *, concrete: bool = False):
 
         return cls
 
-    def as_interface_type(cls, interface: Type[T]) -> T:
+    def as_interface_type(cls, interface: Type[T]) -> Callable[[T], T]:
         if not isinstance(interface, type) or not issubclass(interface, Interface):
             raise TypeError(f"Expected an interface type, got {interface}")
 
         if not issubclass(cls, interface):
             raise TypeError(f"Class {cls.__name__} does not implement interface {interface.__name__}")
 
         if not interface.__explicit__specifications__:
-            return lambda instance: instance
+            return lambda instance: cast(T, instance)
 
         if interface not in cls.__explicit__implementations__:
             raise TypeError(f"Class {cls.__name__} does not implement interface {interface.__name__}")
@@ -133,14 +132,17 @@ def __getattr__(self, name):
                 except AttributeError as e:
                     raise e from None
 
-                try:
-                    return implementation_mapping[specification].__get__(self._instance)
-                except KeyError:
-                    raise TypeError(f"Class {cls.__name__} does not provide an explicit implementation for method '{name}' of interface {interface.__name__}") from None
+                if hasattr(specification, "__declaring_interface__"):
+                    try:
+                        return implementation_mapping[specification].__get__(self._instance)
+                    except KeyError:
+                        raise TypeError(f"Class {cls.__name__} does not provide an explicit implementation for method '{name}' of interface {interface.__name__}") from None
+                
+                return getattr(self._instance, name)
 
-        return ExplicitImplementation
+        return cast(Callable[[T], T], ExplicitImplementation)
 
 
 class Interface(metaclass=InterfaceMeta):
     def as_interface(self, interface: Type[T]) -> T:
-        return type(self).as_interface_type(interface)(self)
+        return type(self).as_interface_type(interface)(cast(T, self))

tests/test_explicit_implementation.py

@@ -30,6 +30,21 @@ def baz(self, z: str) -> float:
         ...
 
 
+class IWithConcreteMethod(Interface):
+    @abstractmethod
+    def abstract_method(self) -> str:
+        ...
+    
+    def concrete_method(self) -> str:
+        """A normal concrete method that should be accessible directly."""
+        return "concrete method result"
+    
+    @classmethod
+    def class_method(cls) -> str:
+        """A class method that should be accessible directly."""
+        return "class method result"
+
+
 class TestInterfaceBasics:
     """Test basic interface functionality."""
 
@@ -316,6 +331,91 @@ def foo_implementation(self, x: int) -> str:
                 # Missing IBar.bar implementation - should raise TypeError
 
 
+class TestConcreteMethodAccess:
+    """Test accessing concrete methods in interfaces directly from concrete classes."""
+    
+    def test_concrete_method_direct_access(self):
+        """Test that concrete methods in interfaces can be accessed directly without explicit implementation."""
+        
+        class Concrete(IWithConcreteMethod):
+            @implements(IWithConcreteMethod.abstract_method)
+            def abstract_method_impl(self) -> str:
+                return "abstract implementation"
+        
+        concrete = Concrete()
+        
+        # Access concrete method directly - should work without explicit implementation
+        result = concrete.concrete_method()
+        assert result == "concrete method result"
+        
+        # Access class method directly - should work without explicit implementation
+        class_result = concrete.class_method()
+        assert class_result == "class method result"
+        
+        # Also test accessing class method on the class itself
+        class_result_from_class = Concrete.class_method()
+        assert class_result_from_class == "class method result"
+        
+        # Verify that the abstract method works through interface casting
+        interface_impl = concrete.as_interface(IWithConcreteMethod)
+        abstract_result = interface_impl.abstract_method()
+        assert abstract_result == "abstract implementation"
+    
+    def test_concrete_method_inheritance_behavior(self):
+        """Test how concrete methods behave with inheritance and overriding."""
+        
+        class Concrete(IWithConcreteMethod):
+            @implements(IWithConcreteMethod.abstract_method)
+            def abstract_method_impl(self) -> str:
+                return "abstract implementation"
+            
+            def concrete_method(self) -> str:
+                """Override the concrete method in the concrete class."""
+                return "overridden concrete method"
+        
+        concrete = Concrete()
+        
+        # Direct access should use the overridden version
+        direct_result = concrete.concrete_method()
+        assert direct_result == "overridden concrete method"
+        
+        # Class method should still work the same way since it's not overridden
+        class_result = concrete.class_method()
+        assert class_result == "class method result"
+        
+        # Concrete methods should be accessible through interface casting
+        # Since there's no explicit implementation, it falls back to the concrete class's method
+        interface_impl = concrete.as_interface(IWithConcreteMethod)
+        interface_result = interface_impl.concrete_method()
+        assert interface_result == "overridden concrete method"  # Uses the concrete class's implementation
+        
+        # Class methods should also be accessible through interface casting
+        interface_class_result = interface_impl.class_method()
+        assert interface_class_result == "class method result"
+    
+    def test_concrete_method_without_override(self):
+        """Test concrete method access when not overridden in concrete class."""
+        
+        class SimpleImplementation(IWithConcreteMethod):
+            @implements(IWithConcreteMethod.abstract_method)
+            def abstract_method_impl(self) -> str:
+                return "simple abstract implementation"
+        
+        concrete = SimpleImplementation()
+        
+        # Direct access should use the interface's concrete method
+        direct_result = concrete.concrete_method()
+        assert direct_result == "concrete method result"
+        
+        # Interface casting should also work and return the same result
+        interface_impl = concrete.as_interface(IWithConcreteMethod)
+        interface_result = interface_impl.concrete_method()
+        assert interface_result == "concrete method result"
+        
+        # Both should be the same since there's no override
+        assert direct_result == interface_result
+
+
 class TestEdgeCases:
     """Test edge cases and boundary conditions."""