refactor: fix Ruff violations across codebase

Author: zigai

objinspect/__init__.py

@@ -14,9 +14,10 @@ def inspect(
     public: bool = True,
     inherited: bool = True,
     static_methods: bool = True,
-    classmethod: bool = False,
+    class_method: bool = False,
     protected: bool = False,
     private: bool = False,
+    **legacy_options: object,
 ) -> Function | Class | Method:
     """
     Inspects an object and returns a structured representation of its attributes and methods.
@@ -32,9 +33,10 @@ def inspect(
         public (bool, optional): Whether to include public attributes and methods.
         inherited (bool, optional): Whether to include inherited attributes and methods.
         static_methods (bool, optional): Whether to include static methods.
-        classmethod (bool, optional): Whether to include class methods.
+        class_method (bool, optional): Whether to include class methods.
         protected (bool, optional): Whether to include protected attributes and methods (prefixed with _).
         private (bool, optional): Whether to include private attributes and methods (prefixed with __).
+        **legacy_options: Backward-compatible keyword options (supports `classmethod`).
 
     Returns:
         An object representing the structure of the inspected object.
@@ -68,13 +70,22 @@ def inspect(
             return Function(obj)
         return Method(obj, cls)
 
+    legacy_classmethod = legacy_options.pop("classmethod", None)
+    if legacy_classmethod is not None:
+        if not isinstance(legacy_classmethod, bool):
+            raise TypeError("`classmethod` must be a bool")
+        class_method = legacy_classmethod
+    if legacy_options:
+        unexpected_keys = ", ".join(sorted(legacy_options))
+        raise TypeError(f"Unexpected keyword argument(s): {unexpected_keys}")
+
     return Class(
         obj,
         init=init,
         public=public,
         inherited=inherited,
         static_methods=static_methods,
-        classmethod=classmethod,
+        class_method=class_method,
         protected=protected,
         private=private,
     )
@@ -107,10 +118,10 @@ def get_class_from_method(method: Callable[..., Any]) -> type | None:
 
 
 __all__ = [
-    "inspect",
     "Class",
     "Function",
     "Method",
-    "Parameter",
     "MethodFilter",
+    "Parameter",
+    "inspect",
 ]

objinspect/_class.py

@@ -1,7 +1,6 @@
 import functools
 import inspect
 from dataclasses import dataclass
-from typing import Any
 
 import docstring_parser
 from docstring_parser import Docstring
@@ -29,7 +28,7 @@ class Class:
         public (bool, optional): Include public methods.
         inherited (bool, optional): Include inherited methods.
         static_methods (bool, optional): Include static methods.
-        classmethod (bool, optional): Include class methods.
+        class_method (bool, optional): Include class methods.
         protected (bool, optional): Include protected methods.
         private (bool, optional): Include private methods.
 
@@ -55,9 +54,19 @@ def __init__(
         static_methods: bool = True,
         protected: bool = False,
         private: bool = False,
-        classmethod: bool = True,
+        class_method: bool = True,
         skip_self: bool = True,
+        **legacy_options: object,
     ) -> None:
+        legacy_classmethod = legacy_options.pop("classmethod", None)
+        if legacy_classmethod is not None:
+            if not isinstance(legacy_classmethod, bool):
+                raise TypeError("`classmethod` must be a bool")
+            class_method = legacy_classmethod
+        if legacy_options:
+            unexpected_keys = ", ".join(sorted(legacy_options))
+            raise TypeError(f"Unexpected keyword argument(s): {unexpected_keys}")
+
         self.cls = cls
         self.skip_self = skip_self
         self.receieved_instance = not inspect.isclass(cls)
@@ -79,13 +88,14 @@ def __init__(
             "static_methods": static_methods,
             "protected": protected,
             "private": private,
-            "classmethod": classmethod,
+            "class_method": class_method,
         }
         self._methods = self._find_methods()
         self.has_init = "__init__" in self._methods
-        self.docstring: Docstring | None = (
-            docstring_parser.parse(self.docstring_text) if self.has_docstring else None  # type: ignore
-        )
+        if self.has_docstring and self.docstring_text is not None:
+            self.docstring: Docstring | None = docstring_parser.parse(self.docstring_text)
+        else:
+            self.docstring = None
         self.description = _get_docstr_description(self.docstring)
 
     def __repr__(self) -> str:
@@ -95,7 +105,9 @@ def __repr__(self) -> str:
     def _class_base(self) -> type:
         if self.is_initialized:
             return self.cls.__class__ if hasattr(self.cls, "__class__") else type(self.cls)
-        return self.cls  # type: ignore[return-value]
+        if isinstance(self.cls, type):
+            return self.cls
+        return type(self.cls)
 
     def _find_methods(self) -> dict[str, Method]:
         method_filter = MethodFilter(**self.extractor_kwargs)
@@ -112,7 +124,7 @@ def _find_methods(self) -> dict[str, Method]:
             methods[method.name] = method
         return methods
 
-    def init(self, *args: Any, **kwargs: Any) -> None:
+    def init(self, *args: object, **kwargs: object) -> None:
         """
         Initializes the class as an instance using the provided arguments.
 
@@ -128,7 +140,7 @@ def init(self, *args: Any, **kwargs: Any) -> None:
             raise TypeError(f"Cannot initialize object of type {type(self.cls)}")
         self.is_initialized = True
 
-    def call_method(self, method: str | int, *args: Any, **kwargs: Any) -> Any:
+    def call_method(self, method: str | int, *args: object, **kwargs: object) -> object:
         """
         Calls the specified method on the class or instance.
 
@@ -189,7 +201,7 @@ def methods(self) -> list[Method]:
         return list(self._methods.values())
 
     @property
-    def dict(self) -> dict[str, Any]:
+    def dict(self) -> dict[str, object]:
         """Return a dictionary representation of the class."""
         return {
             "name": self.name,
@@ -238,10 +250,10 @@ def as_str(
 
 
 def split_init_args(
-    args: dict[str, Any],
+    args: dict[str, object],
     cls: Class,
     method: Method,
-) -> tuple[dict[str, Any], dict[str, Any]]:
+) -> tuple[dict[str, object], dict[str, object]]:
     """
     Split the arguments into those that should be passed to the __init__ method
     and those that should be passed to the method call.

objinspect/constants.py

@@ -1,5 +1,5 @@
 import inspect
 
-EMPTY = inspect._empty
+EMPTY = inspect.Signature.empty
 
 __all__ = ["EMPTY"]

objinspect/function.py

@@ -2,7 +2,6 @@
 from collections.abc import Callable
 from dataclasses import dataclass
 from types import NoneType
-from typing import Any
 
 import docstring_parser
 from docstring_parser import Docstring
@@ -57,15 +56,16 @@ class Function:
 
     """
 
-    def __init__(self, func: Callable[..., Any], skip_self: bool = True) -> None:
+    def __init__(self, func: Callable[..., object], skip_self: bool = True) -> None:
         self.func = func
         self.skip_self = skip_self
         self.name: str = self.func.__name__
         self.docstring_text: str | None = inspect.getdoc(self.func)
         self.has_docstring = _has_docstr(self.docstring_text)
-        self.docstring: Docstring | None = (
-            docstring_parser.parse(self.docstring_text) if self.has_docstring else None  # type: ignore
-        )
+        if self.has_docstring and self.docstring_text is not None:
+            self.docstring: Docstring | None = docstring_parser.parse(self.docstring_text)
+        else:
+            self.docstring = None
         self.return_type = NoneType
         self._parameters = self._get_parameters()
         self.description = _get_docstr_description(self.docstring)
@@ -81,9 +81,8 @@ def _get_parameters(self) -> dict[str, Parameter]:
         if self.docstring is not None:
             params_mapping = {par.arg_name: par for par in self.docstring.params}
             for param in params:
-                if parameter := params_mapping.get(param.name, False):
-                    if parameter.description:  # type: ignore
-                        param.description = parameter.description  # type: ignore
+                if (parameter := params_mapping.get(param.name)) and parameter.description:
+                    param.description = parameter.description
 
         parameters = {}
         for param in params:
@@ -113,7 +112,7 @@ def get_param(self, arg: str | int) -> Parameter:
             case _:
                 raise TypeError(type(arg))
 
-    def call(self, *args: Any, **kwargs: Any) -> Any:
+    def call(self, *args: object, **kwargs: object) -> object:
         """
         Calls the function and returns the result of its call.
 
@@ -129,7 +128,7 @@ def params(self) -> list[Parameter]:
         return list(self._parameters.values())
 
     @property
-    def dict(self) -> dict[str, Any]:
+    def dict(self) -> dict[str, object]:
         """Return a dictionary representation of the function."""
         return {
             "name": self.name,

objinspect/method.py

@@ -1,11 +1,22 @@
 import inspect
 from collections.abc import Callable
 from inspect import _ParameterKind
-from typing import Any
 
 from objinspect.function import Function
 
 
+def _resolve_class_method_option(class_method: bool, legacy_options: dict[str, object]) -> bool:
+    legacy_classmethod = legacy_options.pop("classmethod", None)
+    if legacy_classmethod is not None:
+        if not isinstance(legacy_classmethod, bool):
+            raise TypeError("`classmethod` must be a bool")
+        class_method = legacy_classmethod
+    if legacy_options:
+        unexpected_keys = ", ".join(sorted(legacy_options))
+        raise TypeError(f"Unexpected keyword argument(s): {unexpected_keys}")
+    return class_method
+
+
 class Method(Function):
     """
     The Method class represents a method of a class.
@@ -32,7 +43,7 @@ class Method(Function):
 
     """
 
-    def __init__(self, method: Callable[..., Any], cls: type, skip_self: bool = True) -> None:
+    def __init__(self, method: Callable[..., object], cls: type, skip_self: bool = True) -> None:
         super().__init__(method, skip_self)
         self.cls = cls
 
@@ -44,11 +55,12 @@ def class_instance(self) -> object | None:
     @property
     def is_static(self) -> bool:
         """Whether the method is a static method."""
+        if not inspect.isroutine(self.func):
+            return False
         for cls in inspect.getmro(self.cls):
-            if inspect.isroutine(self.func):
-                if self.name in cls.__dict__:
-                    binded_value = cls.__dict__[self.name]
-                    return isinstance(binded_value, staticmethod)
+            if self.name in cls.__dict__:
+                binded_value = cls.__dict__[self.name]
+                return isinstance(binded_value, staticmethod)
         return False
 
     @property
@@ -94,18 +106,24 @@ def __init__(
         static_methods: bool = True,
         protected: bool = False,
         private: bool = False,
-        classmethod: bool = False,
+        class_method: bool = False,
+        **legacy_options: object,
     ) -> None:
+        class_method = _resolve_class_method_option(class_method, dict(legacy_options))
+
         self.checks: list[Callable[[Method], bool]] = []
-        # fmt: off
-        if not init: self.checks.append(lambda method: method.name == "__init__")
-        if not static_methods: self.checks.append(lambda method: method.is_static)
-        if not inherited: self.checks.append(lambda method: method.is_inherited)
-        if not private: self.checks.append(lambda method: method.is_private)
-        if not protected: self.checks.append(lambda method: method.is_protected)
-        if not public: self.checks.append(lambda method: method.is_public)
-        if not classmethod: self.checks.append(lambda method: method.is_classmethod)
-        # fmt: on
+        filter_checks: tuple[tuple[bool, Callable[[Method], bool]], ...] = (
+            (not init, lambda method: method.name == "__init__"),
+            (not static_methods, lambda method: method.is_static),
+            (not inherited, lambda method: method.is_inherited),
+            (not private, lambda method: method.is_private),
+            (not protected, lambda method: method.is_protected),
+            (not public, lambda method: method.is_public),
+            (not class_method, lambda method: method.is_classmethod),
+        )
+        for enabled, check in filter_checks:
+            if enabled:
+                self.checks.append(check)
 
     def check(self, method: Method) -> bool:
         """
@@ -117,10 +135,7 @@ def check(self, method: Method) -> bool:
         Returns:
             bool: True if the method passes all filters, False otherwise.
         """
-        for check_func in self.checks:
-            if check_func(method):
-                return False
-        return True
+        return all(not check_func(method) for check_func in self.checks)
 
     def extract(self, methods: list[Method]) -> list[Method]:
         """