orionis 0.210.0__py3-none-any.whl → 0.213.0__py3-none-any.whl

orionis/luminate/support/inspection/reflexion_concrete.py

@@ -1,8 +1,7 @@
-from typing import Type, TypeVar
-import abc
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, TypeVar
+import inspect
 
 T = TypeVar('T')
-ABC = TypeVar('ABC', bound=abc.ABC)
 
 class ReflexionConcrete:
     """A reflection object encapsulating a concrete class.
@@ -22,3 +21,256 @@ class ReflexionConcrete:
         """Initialize with the concrete class."""
         self._concrete = concrete
 
+    def getClassName(self) -> str:
+        """Get the name of the concrete class.
+
+        Returns
+        -------
+        str
+            The name of the class
+        """
+        return self._concrete.__name__
+
+    def getClass(self) -> Type:
+        """Get the class of the instance.
+
+        Returns
+        -------
+        Type
+            The class object of the instance
+
+        Examples
+        --------
+        >>> reflex.getClass() is SomeClass
+        True
+        """
+        return self._concrete
+
+    def getModuleName(self) -> str:
+        """Get the name of the module where the class is defined.
+
+        Returns
+        -------
+        str
+            The module name
+        """
+        return self._concrete.__module__
+
+    def getAttributes(self) -> Dict[str, Any]:
+        """Get all class-level attributes.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of attribute names and their values
+        """
+        return {
+            k: v for k, v in vars(self._concrete).items()
+            if not callable(v) and not isinstance(v, staticmethod) and not isinstance(v, classmethod) and not k.startswith('_') and not isinstance(v, property)
+        }
+
+    def getMethods(self) -> List[str]:
+        """Get all method names of the class.
+
+        Returns
+        -------
+        List[str]
+            List of method names
+        """
+        return [
+            name for name, member in inspect.getmembers(self._concrete, predicate=inspect.isfunction)
+            if not name.startswith('_')
+        ]
+
+    def getStaticMethods(self) -> List[str]:
+        """Get all static method names of the class.
+
+        Returns
+        -------
+        List[str]
+            List of static method names, excluding private methods
+        """
+        return [
+            name for name in dir(self._concrete)
+            if not name.startswith('_') and isinstance(inspect.getattr_static(self._concrete, name), staticmethod)
+        ]
+
+    def getPropertyNames(self) -> List[str]:
+        """Get all property names of the class.
+
+        Returns
+        -------
+        List[str]
+            List of property names
+        """
+        return [
+            name for name, val in vars(self._concrete).items()
+            if isinstance(val, property)
+        ]
+
+    def getMethodSignature(self, methodName: str) -> inspect.Signature:
+        """Get the signature of a class method.
+
+        Parameters
+        ----------
+        methodName : str
+            Name of the method
+
+        Returns
+        -------
+        inspect.Signature
+            The method signature
+
+        Raises
+        ------
+        AttributeError
+            If the method doesn't exist
+        """
+        method = getattr(self._concrete, methodName)
+        if callable(method):
+            return inspect.signature(method)
+        raise AttributeError(f"{methodName} is not a valid method.")
+
+    def getPropertySignature(self, propertyName: str) -> inspect.Signature:
+        """Get the signature of a property getter.
+
+        Parameters
+        ----------
+        propertyName : str
+            Name of the property
+
+        Returns
+        -------
+        inspect.Signature
+            The property's getter method signature
+
+        Raises
+        ------
+        AttributeError
+            If the property doesn't exist or is not a property
+        """
+        attr = getattr(self._concrete, propertyName, None)
+        if isinstance(attr, property) and attr.fget is not None:
+            return inspect.signature(attr.fget)
+        raise AttributeError(f"{propertyName} is not a property or doesn't have a getter.")
+
+    def getDocstring(self) -> Optional[str]:
+        """Get the docstring of the class.
+
+        Returns
+        -------
+        Optional[str]
+            The class docstring, or None if not available
+        """
+        return self._concrete.__doc__
+
+    def getBaseClasses(self) -> Tuple[Type, ...]:
+        """Get the base classes of the class.
+
+        Returns
+        -------
+        Tuple[Type, ...]
+            Tuple of base classes
+        """
+        return self._concrete.__bases__
+
+    def isSubclassOf(self, cls: Type) -> bool:
+        """Check if the concrete class is a subclass of another.
+
+        Parameters
+        ----------
+        cls : Type
+            The parent class to check against
+
+        Returns
+        -------
+        bool
+            True if the concrete class is a subclass of the given class
+        """
+        return issubclass(self._concrete, cls)
+
+    def getSourceCode(self) -> Optional[str]:
+        """Get the source code of the class.
+
+        Returns
+        -------
+        Optional[str]
+            The source code if available, None otherwise
+        """
+        try:
+            return inspect.getsource(self._concrete)
+        except (TypeError, OSError):
+            return None
+
+    def getFileLocation(self) -> Optional[str]:
+        """Get the file location where the class is defined.
+
+        Returns
+        -------
+        Optional[str]
+            The file path if available, None otherwise
+        """
+        try:
+            return inspect.getfile(self._concrete)
+        except (TypeError, OSError):
+            return None
+
+    def getAnnotations(self) -> Dict[str, Any]:
+        """Get type annotations of the class.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary of attribute names and their type annotations
+        """
+        return getattr(self._concrete, '__annotations__', {})
+
+    def hasAttribute(self, name: str) -> bool:
+        """Check if the class has a specific attribute.
+
+        Parameters
+        ----------
+        name : str
+            The attribute name to check
+
+        Returns
+        -------
+        bool
+            True if the attribute exists
+        """
+        return hasattr(self._concrete, name)
+
+    def getAttribute(self, name: str) -> Any:
+        """Get a class attribute by name.
+
+        Parameters
+        ----------
+        name : str
+            The attribute name
+
+        Returns
+        -------
+        Any
+            The attribute value
+
+        Raises
+        ------
+        AttributeError
+            If the attribute doesn't exist
+        """
+        return getattr(self._concrete, name)
+
+    def getCallableMembers(self) -> Dict[str, Callable]:
+        """Get all callable members (functions/methods) of the class.
+
+        Returns
+        -------
+        Dict[str, Callable]
+            Dictionary of method names and their callable objects
+        """
+        return {
+            name: member for name, member in inspect.getmembers(
+                self._concrete,
+                callable
+            ) if not name.startswith('__')
+        }

orionis/luminate/support/inspection/reflexion_concrete_with_abstract.py

@@ -1,31 +1,185 @@
-from typing import Type, TypeVar
 import abc
+import inspect
+from typing import Any, Dict, List, Tuple, Type, TypeVar, Union
+from orionis.luminate.support.inspection.reflexion_abstract import ReflexionAbstract
+from orionis.luminate.support.inspection.reflexion_concrete import ReflexionConcrete
 
 T = TypeVar('T')
 ABC = TypeVar('ABC', bound=abc.ABC)
 
-
 class ReflexionConcreteWithAbstract:
-    """A reflection object encapsulating a concrete class and its abstract parent.
+    """Advanced reflection tool for analyzing concrete classes against abstract bases.
+
+    Allows static analysis of class definitions to verify compatibility
+    and adherence to interface contracts without instantiation.
 
     Parameters
     ----------
     concrete : Type[T]
-        The concrete class being reflected upon
+        The concrete class to inspect
     abstract : Type[ABC]
-        The abstract parent class
+        The abstract base class/interface being implemented
 
     Attributes
     ----------
     _concrete : Type[T]
-        The encapsulated concrete class
+        The concrete class being analyzed
     _abstract : Type[ABC]
-        The encapsulated abstract parent class
+        The abstract base class/interface
+    _concrete_reflexion : ReflexionConcrete
+        Reflection helper for the concrete class
+    _abstract_reflexion : ReflexionAbstract
+        Reflection helper for the abstract class
     """
 
     def __init__(self, concrete: Type[T], abstract: Type[ABC]) -> None:
-        """Initialize with the concrete class and abstract parent."""
         self._concrete = concrete
         self._abstract = abstract
+        self._concrete_reflexion = ReflexionConcrete(concrete)
+        self._abstract_reflexion = ReflexionAbstract(abstract)
+
+    @property
+    def concrete(self) -> ReflexionConcrete:
+        """Access the concrete class reflection helper."""
+        return self._concrete_reflexion
+
+    @property
+    def abstract(self) -> ReflexionAbstract:
+        """Access the abstract class reflection helper."""
+        return self._abstract_reflexion
+
+    def getImplementationAnalysis(self) -> Dict[str, Dict[str, Union[bool, str, inspect.Signature]]]:
+        """Comprehensive analysis of implementation compliance."""
+        analysis = {}
+
+        abstract_methods = self._abstract_reflexion.getAbstractMethods()
+        for method in abstract_methods:
+            entry = {
+                'implemented': False,
+                'abstract_signature': None,
+                'concrete_signature': None,
+                'signature_match': False,
+                'type': 'method'
+            }
+
+            if hasattr(self._concrete, method):
+                entry['implemented'] = True
+                abstract_sig = self._abstract_reflexion.getMethodSignature(method)
+                concrete_sig = self._concrete_reflexion.getMethodSignature(method)
+
+                entry.update({
+                    'abstract_signature': abstract_sig,
+                    'concrete_signature': concrete_sig,
+                    'signature_match': (
+                        abstract_sig.parameters == concrete_sig.parameters and
+                        abstract_sig.return_annotation == concrete_sig.return_annotation
+                    )
+                })
+
+            analysis[method] = entry
+
+        abstract_properties = self._abstract_reflexion.getAbstractProperties()
+        for prop in abstract_properties:
+            entry = {
+                'implemented': False,
+                'abstract_signature': None,
+                'concrete_signature': None,
+                'signature_match': False,
+                'type': 'property'
+            }
+
+            if hasattr(self._concrete, prop):
+                entry['implemented'] = True
+                abstract_sig = self._abstract_reflexion.getPropertySignature(prop)
+                concrete_sig = self._concrete_reflexion.getPropertySignature(prop)
+
+                entry.update({
+                    'abstract_signature': abstract_sig,
+                    'concrete_signature': concrete_sig,
+                    'signature_match': (
+                        abstract_sig.parameters == concrete_sig.parameters and
+                        abstract_sig.return_annotation == concrete_sig.return_annotation
+                    )
+                })
+
+            analysis[prop] = entry
+
+        return analysis
+
+    def validateImplementation(self) -> Tuple[bool, Dict[str, List[str]]]:
+        """Validate the implementation against the abstract base."""
+        issues = {
+            'missing': [],
+            'signature_mismatch': [],
+            'type_mismatch': []
+        }
+
+        analysis = self.getImplementationAnalysis()
+        for name, data in analysis.items():
+            if not data['implemented']:
+                issues['missing'].append(name)
+            elif not data['signature_match']:
+                issues['signature_mismatch'].append(name)
+                abstract_return = data['abstract_signature'].return_annotation
+                concrete_return = data['concrete_signature'].return_annotation
+                if abstract_return != concrete_return and abstract_return is not inspect.Parameter.empty:
+                    issues['type_mismatch'].append(name)
+
+        is_valid = not any(issues.values())
+        return (is_valid, issues)
+
+    def getImplementationCoverage(self) -> float:
+        """Calculate the percentage of abstract methods/properties implemented."""
+        analysis = self.getImplementationAnalysis()
+        total = len(analysis) * 2
+        implemented = 0
+        for item in analysis.values():
+            if item['implemented']:
+                implemented += 2 if item['signature_match'] else 1
+        return implemented / total if total else 0.0
+
+    def getNonInheritedImplementation(self) -> Dict[str, Any]:
+        """Get implementation details for methods, properties, and attributes not inherited from the abstract base."""
+        concrete_members = set(dir(self._concrete))
+        base_members = set(dir(self._abstract))
+
+        non_inherited_methods = [
+            name for name in concrete_members
+            if callable(getattr(self._concrete, name, None)) and name not in base_members
+        ]
+
+        non_inherited_properties = [
+            name for name in concrete_members
+            if isinstance(getattr(self._concrete, name, None), property) and name not in base_members
+        ]
+
+        non_inherited_attributes = {
+            name: getattr(self._concrete, name, None)
+            for name in concrete_members
+            if (
+                not callable(getattr(self._concrete, name, None)) and
+                not isinstance(getattr(self._concrete, name, None), property) and
+                name not in base_members
+            )
+        }
+
+        return {
+            'methods': non_inherited_methods,
+            'properties': non_inherited_properties,
+            'attributes': non_inherited_attributes
+        }
+
+    def getHierarchyAnalysis(self) -> Dict[str, List[str]]:
+        """Analyze the class hierarchy relationships."""
+        concrete_hierarchy = [cls.__name__ for cls in inspect.getmro(self._concrete)]
+        abstract_hierarchy = [cls.__name__ for cls in inspect.getmro(self._abstract)]
 
+        concrete_bases = set(inspect.getmro(self._concrete))
+        abstract_bases = set(inspect.getmro(self._abstract))
+        common = concrete_bases & abstract_bases - {self._abstract, object}
 
+        return {
+            'concrete_hierarchy': concrete_hierarchy,
+            'abstract_hierarchy': abstract_hierarchy,
+            'common_ancestors': [cls.__name__ for cls in common]
+        }

{orionis-0.210.0.dist-info → orionis-0.213.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: orionis
-Version: 0.210.0
+Version: 0.213.0
 Summary: Orionis Framework – Elegant, Fast, and Powerful.
 Home-page: https://github.com/orionis-framework/framework
 Author: Raul Mauricio Uñate Castro

{orionis-0.210.0.dist-info → orionis-0.213.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 orionis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/console.py,sha256=4gYWxf0fWYgJ4RKwARvnTPh06FL3GJ6SAZ7R2NzOICw,1342
-orionis/framework.py,sha256=ktf77HKAC_3ZhF5oKg7CiAVmLkW_QmL_xrrzI7grIKU,1469
+orionis/framework.py,sha256=h535GtyAp9Bsjr4Ao052lL6yCui73xb5BWR70PDbLig,1469
 orionis/installer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/installer/manager.py,sha256=Li4TVziRXWfum02xNG4JHwbnLk-u8xzHjdqKz-D894k,2755
 orionis/installer/output.py,sha256=7O9qa2xtXMB_4ZvVi-Klneom9YazwygAd_4uYAoxhbU,8548
@@ -167,11 +167,11 @@ orionis/luminate/support/reflection.py,sha256=TbWZ_cer0PXrPlwCYFbUJRymlzYxXT0E4C
 orionis/luminate/support/std.py,sha256=TqrgMxF_i5ubYGT5LOvHCH7HOHNmI8CE1kG9pNoSniY,1390
 orionis/luminate/support/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 orionis/luminate/support/inspection/container_integrity.py,sha256=6d9FsGk-Rm1AXgqBS3Nww49dR7n1ptXTTNyGUuBHgNY,10111
-orionis/luminate/support/inspection/functions.py,sha256=XVDLdygONcfDNlH7CZ6muNdtYHLgNp5RybqC3smL4Y4,6400
-orionis/luminate/support/inspection/reflection.py,sha256=x_UHBY9pBSKgct13-u1WbhoONqLoGG60OpgoCsKE0AI,20368
+orionis/luminate/support/inspection/functions.py,sha256=4wDT7iNp-5l4vuHk0UsIxN9wakASJRD4V0KY24uMDzk,7227
+orionis/luminate/support/inspection/reflection.py,sha256=mOCamaKv1ED-Q60_01HMzsCAhoCFeDK7ZqYZ3iYepsM,7716
 orionis/luminate/support/inspection/reflexion_abstract.py,sha256=U_VAGQN0ZDMgjxYPhNrLxFt6F8_-8zXcA_B5djTV4GE,10731
-orionis/luminate/support/inspection/reflexion_concrete.py,sha256=0WOlLeTWLwMeAUReoaJetqlnT1_TxW_jMnbk_yXRR0g,549
-orionis/luminate/support/inspection/reflexion_concrete_with_abstract.py,sha256=ZuAFoSPkgbOFMIbVR0hvlkKsm1dIpY1_bsXxZxvXcmU,801
+orionis/luminate/support/inspection/reflexion_concrete.py,sha256=1ISuy2L6Oser-EhmpuGALmbauh7Z-X8Rx1YYgt5CabQ,7543
+orionis/luminate/support/inspection/reflexion_concrete_with_abstract.py,sha256=z1cAscuG6a1E4ZJmwkp9HVQ0yhTAeFYKfnnyR_M-RFI,7480
 orionis/luminate/support/inspection/reflexion_instance.py,sha256=LNAgw4sZvHT7UMiObHTGk7xgqpIeKYHAQRgRpuPfEas,10842
 orionis/luminate/support/inspection/reflexion_instance_with_abstract.py,sha256=PI_VSH8baxjPgheOYc9tQAlLq9mjxGm5zCOr-bLVksg,9406
 orionis/luminate/support/inspection/reflexion_module.py,sha256=OgBXpqNJHkmq-gX4rqFStv-WVNe9R38RsgUgfHpak8k,405
@@ -199,15 +199,19 @@ tests/example/test_example.py,sha256=8EYjl1b-J_479dmJdQoAcKCKr7JUydW7EmPQpeiF13Y
 tests/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/inspection/test_reflection_abstract.py,sha256=K78avxUlI_dYKofSvVcuaVLAz-CivWSe3RkhrO-IRcA,9185
-tests/support/inspection/test_reflection_instance.py,sha256=qwYu_y3wiZzhegrRo97r1bWxW2YGxDdnnU-Hq4lZtAE,6930
-tests/support/inspection/test_reflection_instance_with_abstract.py,sha256=RNLf9RfRtM2nTY6Yfc8rPibSEVZkl8Pw2w962vsragk,4048
+tests/support/inspection/test_reflection_concrete.py,sha256=dvO7dduJMCsioCxZ5i2WW6V5-3z5LR6gIgGvBGaQcNI,6542
+tests/support/inspection/test_reflection_concrete_with_abstract.py,sha256=G29gqevXQd7TBOluaPpK6ER-24a4uK-zaImamig7cEE,4650
+tests/support/inspection/test_reflection_instance.py,sha256=iwwf-QY-O3kR_HTHdATUnu9iXn6Nat7d8Y8Hxhwfpb0,6938
+tests/support/inspection/test_reflection_instance_with_abstract.py,sha256=RQkw2BYY8TLuk6h_9NIa_5JfRL7RG8004ro252t6YF8,4059
 tests/support/inspection/fakes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/support/inspection/fakes/fake_reflection_abstract.py,sha256=7qtz44brfFzE4oNYi9kIsvdWP79nP2FnzSz-0bU__pg,5045
+tests/support/inspection/fakes/fake_reflection_concrete.py,sha256=j6gzsxE3xq5oJ30H_Hm1RsUwEY3jOYBu4sclxtD1ayo,1047
+tests/support/inspection/fakes/fake_reflection_concrete_with_abstract.py,sha256=ibCjrtNM6BMf5Z5VMvat7E6zOAk5g9z--gj4ykKJWY8,2118
 tests/support/inspection/fakes/fake_reflection_instance.py,sha256=G16rZdJWC3L8SGEQkmwktvw4n7IAusIIx9Tm-ZFLcg4,1419
 tests/support/inspection/fakes/fake_reflection_instance_with_abstract.py,sha256=SfL8FuFmr650RlzXTrP4tGMfsPVZLhOxVnBXu_g1POg,1471
-orionis-0.210.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
-orionis-0.210.0.dist-info/METADATA,sha256=lDNgDlBv95FLobuXCOJdgmXaXKt4SA5NkDmViO8yI1w,3003
-orionis-0.210.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-orionis-0.210.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
-orionis-0.210.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
-orionis-0.210.0.dist-info/RECORD,,
+orionis-0.213.0.dist-info/LICENCE,sha256=-_4cF2EBKuYVS_SQpy1uapq0oJPUU1vl_RUWSy2jJTo,1111
+orionis-0.213.0.dist-info/METADATA,sha256=AAJOh4awPCmTybz8JgS7tMkkRL6nv6mLVrptKugaYS0,3003
+orionis-0.213.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+orionis-0.213.0.dist-info/entry_points.txt,sha256=a_e0faeSqyUCVZd0MqljQ2oaHHdlsz6g9sU_bMqi5zQ,49
+orionis-0.213.0.dist-info/top_level.txt,sha256=2bdoHgyGZhOtLAXS6Om8OCTmL24dUMC_L1quMe_ETbk,14
+orionis-0.213.0.dist-info/RECORD,,

tests/support/inspection/fakes/fake_reflection_concrete.py

@@ -0,0 +1,44 @@
+class BaseExample:
+    """Base class to test inheritance."""
+
+    def baseMethod(self) -> str:
+        return "Base method called"
+
+class FakeExample(BaseExample):
+    """This is a fake example class for testing reflection."""
+
+    class_attr: int = 42
+    another_attr = "hello"
+
+    def __init__(self, value: int = 10) -> None:
+        self.instance_attr = value
+
+    @property
+    def prop(self) -> int:
+        """A read-only property returning a fixed number."""
+        return 10
+
+    @property
+    def prop_with_getter(self) -> str:
+        return "read-only"
+
+    def method_one(self, x: int) -> int:
+        return x * 2
+
+    def method_two(self, a: str, b: str = "default") -> str:
+        return a + b
+
+    @staticmethod
+    def static_method() -> str:
+        return "I am static"
+
+    @staticmethod
+    def _private_static():
+        pass
+
+    @classmethod
+    def class_method(cls) -> str:
+        return f"I am class method of {cls.__name__}"
+
+    def _private_method(self):
+        pass

tests/support/inspection/fakes/fake_reflection_concrete_with_abstract.py

@@ -0,0 +1,78 @@
+import abc
+from typing import Any, Dict, List
+
+class AbstractService(abc.ABC):
+    """
+    Abstract interface for service-like behavior.
+
+    Methods
+    -------
+    process(data: str) -> bool
+        Perform processing on input data.
+
+    reset() -> None
+        Reset the internal state of the service.
+
+    configure(options: Dict[str, Any]) -> None
+        Apply configuration settings to the service.
+
+    get_logs(limit: int = 10) -> List[str]
+        Retrieve a limited number of log messages.
+
+    Properties
+    ----------
+    status : str
+        Current status of the service.
+    """
+
+    @abc.abstractmethod
+    def process(self, data: str) -> bool:
+        """Perform processing on input data."""
+        pass
+
+    @abc.abstractmethod
+    def reset(self) -> None:
+        """Reset the internal state of the service."""
+        pass
+
+    @abc.abstractmethod
+    def configure(self, options: Dict[str, Any]) -> None:
+        """Apply configuration settings to the service."""
+        pass
+
+    @abc.abstractmethod
+    def get_logs(self, limit: int = 10) -> List[str]:
+        """Retrieve a limited number of log messages."""
+        pass
+
+    @property
+    @abc.abstractmethod
+    def status(self) -> str:
+        """Current status of the service."""
+        pass
+
+class PartiallyImplementedService:
+    """
+    A partial implementation of AbstractService.
+
+    This class mimics the interface but lacks some methods/properties,
+    making it useful for testing reflection-based validation.
+    """
+
+    def process(self, data: str) -> bool:
+        """Basic processing implementation."""
+        return bool(data)
+
+    def get_logs(self, limit: int = 10) -> List[str]:
+        """Return a fixed list of logs (mock implementation)."""
+        return [f"log {i}" for i in range(limit)]
+
+    # ❌ Missing: reset()
+    # ❌ Missing: configure()
+    # ❌ Missing: status (property)
+
+    def extra(self) -> str:
+        """An extra method not part of the abstract interface."""
+        return "Just extra"
+
+    version: str = "1.0"