improve type hints

Author: zigai

objinspect/__init__.py

@@ -1,5 +1,6 @@
 import inspect as _inspect
 from collections.abc import Callable
+from typing import Any
 
 from objinspect._class import Class
 from objinspect.function import Function
@@ -76,7 +77,7 @@ def inspect(
     )
 
 
-def get_class_from_method(method: Callable):
+def get_class_from_method(method: Callable[..., Any]) -> type | None:
     qualname = method.__qualname__
     module = _inspect.getmodule(method)
     if "." in qualname:

objinspect/_class.py

@@ -45,23 +45,23 @@ class Class:
 
     def __init__(
         self,
-        cls,
-        init=True,
-        public=True,
-        inherited=True,
-        static_methods=True,
-        protected=False,
-        private=False,
-        classmethod=True,
-        skip_self=True,
+        cls: type | object,
+        init: bool = True,
+        public: bool = True,
+        inherited: bool = True,
+        static_methods: bool = True,
+        protected: bool = False,
+        private: bool = False,
+        classmethod: bool = True,
+        skip_self: bool = True,
     ) -> None:
         self.cls = cls
         self.is_initialized = False
         self.skip_self = skip_self
         self.receieved_instance = False
 
         try:
-            self.name: str = self.cls.__name__
+            self.name: str = getattr(self.cls, "__name__", str(self.cls))
         except AttributeError:
             self.receieved_instance = True
             self.name = f"{self.cls.__class__.__name__} instance"
@@ -90,10 +90,10 @@ def __repr__(self) -> str:
         return f"{self.__class__.__name__}(name='{self.name}', methods={len(self._methods)}, has_init={self.has_init}, description={self.description})"
 
     @functools.cached_property
-    def _class_base(self):
+    def _class_base(self) -> type:
         if self.is_initialized:
-            return self.cls.__class__
-        return self.cls
+            return self.cls.__class__ if hasattr(self.cls, "__class__") else type(self.cls)
+        return self.cls  # type: ignore[return-value]
 
     def _find_methods(self) -> dict[str, Method]:
         method_filter = MethodFilter(**self.extractor_kwargs)
@@ -106,7 +106,7 @@ def _find_methods(self) -> dict[str, Method]:
             methods[method.name] = method
         return methods
 
-    def init(self, *args, **kwargs) -> None:
+    def init(self, *args: Any, **kwargs: Any) -> None:
         """
         Initializes the class as an instance using the provided arguments.
 
@@ -116,10 +116,13 @@ def init(self, *args, **kwargs) -> None:
         """
         if self.is_initialized:
             raise ValueError(f"Class {self.cls} is already initialized")
-        self.instance = self.cls(*args, **kwargs)
+        if callable(self.cls):
+            self.instance = self.cls(*args, **kwargs)
+        else:
+            raise TypeError(f"Cannot initialize object of type {type(self.cls)}")
         self.is_initialized = True
 
-    def call_method(self, method: str | int, *args, **kwargs) -> Any:
+    def call_method(self, method: str | int, *args: Any, **kwargs: Any) -> Any:
         """
         Calls the specified method on the class or instance.
 
@@ -160,7 +163,7 @@ def get_method(self, method: str | int) -> Method:
                 raise TypeError(type(method))
 
     @property
-    def init_method(self):
+    def init_method(self) -> Method | None:
         try:
             return self.get_method("__init__")
         except KeyError:
@@ -188,11 +191,16 @@ def dict(self) -> dict[str, Any]:
         }
 
     def as_str(
-        self, *, color: bool = True, indent: int = 2, theme: ClassStrTheme | None = None
+        self,
+        *,
+        color: bool = True,
+        indent: int = 2,
+        theme: ClassStrTheme | None = None,
     ) -> str:
         if theme is None:
             theme = ClassStrTheme()
 
+        string: str
         if color:
             string = colored("class", theme.class_kw) + " " + colored(self.name, theme.name) + ":"
         else:
@@ -202,7 +210,7 @@ def as_str(
             if color:
                 string += "\n" + colored(self.description, theme.description)
             else:
-                string += "\n" + self.description
+                string += "\n" + str(self.description)
         if not len(self.methods):
             return string
 
@@ -211,7 +219,11 @@ def as_str(
         return string
 
 
-def split_init_args(args: dict, cls: Class, method: Method) -> tuple[dict, dict]:
+def split_init_args(
+    args: dict[str, Any],
+    cls: Class,
+    method: Method,
+) -> tuple[dict[str, Any], dict[str, Any]]:
     """
     Split the arguments into those that should be passed to the __init__ method
     and those that should be passed to the method call.

objinspect/function.py

@@ -56,7 +56,7 @@ class Function:
 
     """
 
-    def __init__(self, func: Callable, skip_self: bool = True) -> None:
+    def __init__(self, func: Callable[..., Any], skip_self: bool = True) -> None:
         self.func = func
         self.skip_self = skip_self
         self.name: str = self.func.__name__
@@ -113,7 +113,7 @@ def get_param(self, arg: str | int) -> Parameter:
             case _:
                 raise TypeError(type(arg))
 
-    def call(self, *args, **kwargs) -> Any:
+    def call(self, *args: Any, **kwargs: Any) -> Any:
         """
         Calls the function and returns the result of its call.
 
@@ -161,27 +161,28 @@ def as_str(
         if theme is None:
             theme = FunctionStrTheme()
 
-        name_str = self.name if not color else colored(self.name, theme.name)
-        params = ", ".join([i.as_str(color=color) for i in self.params])
+        name_str: str = self.name if not color else colored(self.name, theme.name)
+        params: str = ", ".join([i.as_str(color=color) for i in self.params])
         if color:
             params = colored("(", theme.bracket) + params + colored(")", theme.bracket)
 
-        if self.return_type is not EMPTY:
-            return_str = type_name(self.return_type)
+        if self.return_type is not EMPTY and self.return_type is not None:  # type: ignore[comparison-overlap]
+            return_str: str = type_name(self.return_type)
             if color:
                 return_str = colored(return_str, theme.ret)
             return_str = " -> " + return_str
         else:
             return_str = ""
 
-        string = f"{name_str}{params}{return_str}"
+        string: str = f"{name_str}{params}{return_str}"
 
         if description and self.description:
             string = ansi_ljust(string, ljust)
             description_str = f" # {self.description}"
             if color:
                 description_str = colored(description_str, theme.description)
-            return string + description_str
+            string += description_str
+            return string
         return string
 
 

objinspect/method.py

@@ -1,5 +1,7 @@
 import inspect
+from collections.abc import Callable
 from inspect import _ParameterKind
+from typing import Any
 
 from objinspect.function import Function
 
@@ -30,12 +32,12 @@ class Method(Function):
 
     """
 
-    def __init__(self, method, cls, skip_self: bool = True):
+    def __init__(self, method: Callable[..., Any], cls: type, skip_self: bool = True) -> None:
         super().__init__(method, skip_self)
         self.cls = cls
 
     @property
-    def class_instance(self):
+    def class_instance(self) -> object | None:
         return getattr(self.func, "__self__", None)
 
     @property
@@ -83,7 +85,7 @@ def __init__(
         private: bool = False,
         classmethod: bool = False,
     ) -> None:
-        self.checks = []
+        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)
@@ -104,9 +106,13 @@ def extract(self, methods: list[Method]) -> list[Method]:
         return [i for i in methods if self.check(i)]
 
 
-def split_args_kwargs(func_args: dict, func: Function | Method) -> tuple[tuple, dict]:
+def split_args_kwargs(
+    func_args: dict[str, object],
+    func: Function | Method,
+) -> tuple[tuple[object, ...], dict[str, object]]:
     """Split the arguments passed to a function into positional and keyword arguments."""
-    args, kwargs = [], {}
+    args: list[object] = []
+    kwargs: dict[str, object] = {}
     for param in func.params:
         if param.kind == _ParameterKind.POSITIONAL_ONLY:
             args.append(func_args[param.name])

objinspect/parameter.py

@@ -53,34 +53,34 @@ def __init__(
         if infer_type and not self.is_typed:
             self.type = self.get_infered_type()
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         data = f"name='{self.name}', kind={str(self.kind)}, type={self.type}, default={self.default}, description='{self.description}'"
         return f"{self.__class__.__name__}({data})"
 
-    def get_infered_type(self):
+    def get_infered_type(self) -> Any:
         """Infer the type of the parameter based on its default value."""
         if self.default is EMPTY:
             return EMPTY
         return type(self.default)
 
     @property
     def is_typed(self) -> bool:
-        return self.type != EMPTY
+        return self.type is not EMPTY
 
     @property
     def is_required(self) -> bool:
-        return self.default == EMPTY
+        return self.default is EMPTY
 
     @property
     def is_optional(self) -> bool:
         return not self.is_required
 
     @property
     def has_default(self) -> bool:
-        return self.default != EMPTY
+        return self.default is not EMPTY
 
     @property
-    def dict(self):
+    def dict(self) -> dict[str, Any]:
         return {
             "name": self.name,
             "kind": self.kind,
@@ -124,7 +124,7 @@ def from_inspect_param(
         cls,
         param: inspect.Parameter,
         description: str | None = None,
-    ):
+    ) -> "Parameter":
         return cls(
             name=param.name,
             type=param.annotation,

objinspect/prettydir.py

@@ -39,9 +39,9 @@ def prettydir(
         "__annotations__",
         "__module__",
     ]
-    METHOD_SKIPS = []
+    METHOD_SKIPS: list[str] = []
 
-    def is_dunder(name: str):
+    def is_dunder(name: str) -> bool:
         return name.startswith("__") and name.endswith("__")
 
     if sep:

objinspect/typing.py

@@ -59,7 +59,7 @@ def simplified_type_name(name: str) -> str:
     return name
 
 
-def is_generic_alias(t) -> bool:
+def is_generic_alias(t: Any) -> bool:
     """
     Check if a type is an alias type (list[str], dict[str, int], etc...])
 
@@ -77,7 +77,7 @@ def is_generic_alias(t) -> bool:
     return type(t) in ALIAS_TYPES
 
 
-def is_union_type(t) -> bool:
+def is_union_type(t: Any) -> bool:
     """
     Check if a type is a union type (float | int, str | None, etc...)
 
@@ -95,7 +95,7 @@ def is_union_type(t) -> bool:
     return type(t) in UNION_TYPES
 
 
-def is_iterable_type(t) -> bool:
+def is_iterable_type(t: Any) -> bool:
     """
     Check if a type is an iterable type (list, tuple, etc...)
 
@@ -150,7 +150,7 @@ def is_iterable_type(t) -> bool:
         return False
 
 
-def is_mapping_type(t) -> bool:
+def is_mapping_type(t: Any) -> bool:
     """
     Check if a type is a mapping type (dict, OrderedDict, etc...)
 
@@ -212,7 +212,7 @@ def is_enum(t: Any) -> bool:
     return isinstance(t, EnumMeta)
 
 
-def get_enum_choices(e) -> tuple[str, ...]:
+def get_enum_choices(e: Any) -> tuple[str, ...]:
     """
     Get the options of a Python Enum.
 
@@ -297,7 +297,7 @@ def is_or_contains_literal(t: Any) -> bool:
     return False
 
 
-def get_literal_choices(literal_t) -> tuple[str, ...]:
+def get_literal_choices(literal_t: Any) -> tuple[str, ...]:
     """Get the options of a Python Literal."""
     if is_direct_literal(literal_t):
         return typing.get_args(literal_t)
@@ -307,7 +307,7 @@ def get_literal_choices(literal_t) -> tuple[str, ...]:
     raise ValueError(f"{literal_t} is not a literal")
 
 
-def literal_contains(literal_t, value: Any) -> bool:
+def literal_contains(literal_t: Any, value: Any) -> bool:
     """Check if a value is in a Python Literal."""
     if not is_direct_literal(literal_t):
         raise ValueError(f"{literal_t} is not a literal")
@@ -318,7 +318,7 @@ def literal_contains(literal_t, value: Any) -> bool:
     return value in values
 
 
-def get_choices(t: type) -> tuple | None:
+def get_choices(t: Any) -> tuple[Any, ...] | None:
     """
     Try to get the choices of a Literal or Enum type.
     Will also work with a Union type that contains Literal or Enum types.
@@ -330,7 +330,7 @@ def get_choices(t: type) -> tuple | None:
         return get_enum_choices(t)
     if is_union_type(t):
         args = type_args(t)
-        choices = []
+        choices: list[Any] = []
         for i in args:
             if is_enum(i):
                 choices.extend(get_enum_choices(i))