Source code
import sys
import threading
from collections.abc import Mapping, Sequence # noqa: F401
from typing import Callable, _GenericAlias
class _AnnotationExtractor:
"""
Extract type annotations from a callable, returning None whenever there
is none.
"""
__slots__ = ["sig"]
def __init__(self, callable):
import inspect
try:
self.sig = inspect.signature(callable)
except (ValueError, TypeError): # inspect failed
self.sig = None
def get_first_param_type(self):
"""
Return the type annotation of the first argument if it's not empty.
"""
import inspect
if not self.sig:
return None
params = list(self.sig.parameters.values())
if params and params[0].annotation is not inspect.Parameter.empty:
return params[0].annotation
return None
def get_return_type(self):
"""
Return the return type if it's not empty.
"""
import inspect
if (
self.sig
and self.sig.return_annotation is not inspect.Signature.empty
):
return self.sig.return_annotation
return None
Run 1
The code is generally readable with clear class and method names, sensible docstrings, and consistent use of imports. Structure is logical, nesting is minimal, and actions are mostly one per line. Some issues slightly reduce clarity: the `__slots__` attribute is unnecessary for an extractor class, imports are scattered inside methods rather than centralized, and the `get_first_param_type` method creates a list unnecessarily. The conditional in `get_return_type` spans multiple lines and could be simplified for better flow. Overall, intent is clear but minor redundancies and import placement slightly hinder readability.
Run 2
The code is generally readable with clear naming and docstrings. However, several issues reduce its score: repeated 'import inspect' inside methods is unnecessary and disrupts flow; the class name '_AnnotationExtractor' suggests internal use but lacks clarity on purpose; nested conditionals in get_first_param_type and get_return_type could be flattened; the unused imports (sys, threading, Mapping, Sequence, Callable, _GenericAlias) add noise; and the class design could be simplified by extracting the signature once and returning None early. The structure is logical but somewhat over-engineered for the simple task. Overall, it's maintainable but not exemplary.
Run 3
The code is well-structured with a clear single responsibility class, flat nesting, and logical method separation. Imports inside methods are a minor inconsistency but intentional for lazy loading. Docstrings clearly explain intent. The 'get_first_param_type' method could be slightly simplified, and the top imports include 'Mapping', 'Sequence', and '_GenericAlias' that are unused, which adds minor noise. Overall readability is high due to concise methods, natural flow, and good naming.
Run 1
Code Structure: A focused class separates signature extraction from parameter and return annotation retrieval. Nesting: Shallow conditionals and early returns keep control flow simple. Clarity of intent: Descriptive method names and docstrings explain the purpose, although 'sig' is abbreviated and 'callable' shadows a built-in. Code length: Concise overall, but unused top-level imports and repeated local inspect imports add clutter. Action granularity: Each statement performs a clear, discrete action. Reading flow: Methods follow a natural initialization-and-query sequence, with consistent spacing and straightforward exception handling. The unnecessarily split return-type condition slightly interrupts an otherwise smooth reading experience.
Run 2
Code Structure: The class cleanly separates signature extraction from parameter and return annotation retrieval. Nesting: Minimal nesting and early returns make control paths easy to follow. Clarity of intent: Descriptive method names and brief docstrings clearly communicate purpose, although 'sig' is abbreviated and 'callable' shadows a built-in. Code length: Compact overall, but unused module imports and repeated local inspect imports add clutter. Action granularity: Each statement performs a single clear action, with no compressed multi-action lines. Reading flow: Initialization followed by two focused accessor methods creates a natural progression; the multiline return-annotation condition slightly interrupts an otherwise smooth flow.
Run 3
Code Structure: The class logically groups signature extraction and annotation access into small, focused methods. Nesting: Shallow conditionals and early returns keep complexity low. Clarity of intent: Descriptive method names and docstrings clearly explain the purpose, though the parameter name callable shadows a built-in and sig is abbreviated. Code length: Methods are concise, but repeated local inspect imports and several unused module imports add clutter. Action granularity: Each statement performs one clear action, with no compressed multi-action lines. Reading flow: Initialization followed by parameter and return annotation retrieval creates a natural progression. The multiline return-annotation condition slightly interrupts an otherwise straightforward flow.