refactor: replace getattr with direct attribute access

Author: zigai

interfacy/appearance/layout.py

@@ -165,20 +165,23 @@ class HelpLayout:
     )
 
     layout_mode: Literal["auto", "adaptive", "template"] = "auto"
+    subcommand_usage_token: str | None = None
 
     # "bold":  remove backticks in docstring and make text bold
     # "strip": remove backticks in docstring and leave plain text
     doc_inline_code_mode: Literal["bold", "strip"] = "bold"
+    _default_field_width_base: int | None = field(default=None, init=False, repr=False)
+    _pos_flag_width_base: int | None = field(default=None, init=False, repr=False)
 
     def _get_default_field_width_base(self) -> int:
-        base = getattr(self, "_default_field_width_base", None)
+        base = self._default_field_width_base
         if base is None:
             base = self.default_field_width
             self._default_field_width_base = base
         return base
 
     def _get_pos_flag_width_base(self) -> int:
-        base = getattr(self, "_pos_flag_width_base", None)
+        base = self._pos_flag_width_base
         if base is None:
             base = self.pos_flag_width
             self._pos_flag_width_base = base
@@ -194,7 +197,7 @@ def _compute_default_field_width_for_len(self, max_len: int) -> int:
         except (OSError, AttributeError):
             term_width = 80
 
-        ratio = max(1, getattr(self, "default_field_width_term_ratio", 5))
+        ratio = max(1, self.default_field_width_term_ratio)
         term_cap = max(base_width, term_width // ratio)
         if self.default_field_width_max is not None:
             term_cap = min(term_cap, self.default_field_width_max)
@@ -212,9 +215,9 @@ def _compute_default_field_width_from_lengths(self, lengths: list[int]) -> int:
         except (OSError, AttributeError):
             term_width = 80
 
-        ratio = max(1, getattr(self, "default_field_width_term_ratio", 5))
+        ratio = max(1, self.default_field_width_term_ratio)
         term_cap = max(base_width, term_width // ratio)
-        soft_ratio = max(1, getattr(self, "default_field_width_soft_ratio", 8))
+        soft_ratio = max(1, self.default_field_width_soft_ratio)
         soft_cap = max(base_width, term_width // soft_ratio)
         effective_cap = min(term_cap, soft_cap)
         if self.default_field_width_max is not None:
@@ -323,7 +326,7 @@ def get_parser_command_usage_suffix(self) -> str:
 
     def get_subcommand_usage_token(self) -> str:
         """Return the subcommand placeholder token used in usage lines."""
-        legacy_placeholder = getattr(self, "subcommand_usage_token", None)
+        legacy_placeholder = self.subcommand_usage_token
         if isinstance(legacy_placeholder, str):
             return legacy_placeholder
         return self.subcommand_usage_placeholder

interfacy/appearance/type_help.py

@@ -71,9 +71,9 @@ def format(self, annotation: object) -> str:
 
     def _resolve_type_token_styles(self) -> dict[str, TextStyle]:
         def pick(name: str) -> TextStyle:
-            if self.theme is not None and hasattr(self.theme, name):
-                return getattr(self.theme, name)
-            return self.style
+            if self.theme is None:
+                return self.style
+            return getattr(self.theme, name)
 
         return {
             "name": self.style,

interfacy/argparse_backend/help_formatter.py

@@ -54,7 +54,7 @@ def start_section(self, heading: str | None) -> None:
         """
         layout = self._get_help_layout()
         if layout is not None and heading not in (None, argparse.SUPPRESS):
-            title_map = getattr(layout, "section_title_map", None)
+            title_map = layout.section_title_map
             heading_text = str(heading).strip()
             heading_key = heading_text.rstrip(":").strip().lower()
             if isinstance(title_map, dict):
@@ -65,7 +65,7 @@ def start_section(self, heading: str | None) -> None:
                 )
                 if mapped:
                     heading = mapped
-            heading_style = getattr(layout, "section_heading_style", None)
+            heading_style = layout.section_heading_style
             if heading_style is not None:
                 heading = with_style(str(heading), heading_style)
         return super().start_section(heading)
@@ -92,7 +92,7 @@ def _primary_boolean_option_strings(action: argparse.Action) -> list[str]:
         if base_flag and not no_flag:
             no_flag = f"--no-{base_flag[2:]}"
 
-        default_val = getattr(action, "default", False)
+        default_val = action.default
         primary_long = no_flag if bool(default_val) and no_flag else (base_flag or longs[0])
 
         normalized: list[str] = []
@@ -249,10 +249,10 @@ def _format_usage(
 
         layout = self._get_help_layout()
         if layout is not None:
-            custom_prefix = getattr(layout, "usage_prefix", None)
+            custom_prefix = layout.usage_prefix
             if custom_prefix is not None:
                 prefix = custom_prefix
-                usage_style = getattr(layout, "usage_style", None)
+                usage_style = layout.usage_style
                 if usage_style is not None:
                     prefix = with_style(prefix, usage_style)
 
@@ -335,15 +335,15 @@ def get_lines(
 
         usage_text_style = None
         if layout is not None:
-            custom_prefix = getattr(layout, "usage_prefix", None)
+            custom_prefix = layout.usage_prefix
             if isinstance(usage, str) and custom_prefix is not None:
                 usage = re.sub(
                     r"^(?:\x1b\[[0-9;]*m)*\s*usage:\s*",
                     "",
                     usage,
                     flags=re.IGNORECASE,
                 )
-            usage_text_style = getattr(layout, "usage_text_style", None)
+            usage_text_style = layout.usage_text_style
         if usage_text_style is not None and isinstance(usage, str):
             usage = with_style(usage, usage_text_style)
 

interfacy/click_backend/commands.py

@@ -6,6 +6,7 @@
 import click
 from click.formatting import iter_rows, measure_table, term_len, wrap_text
 
+from interfacy.appearance.layout import HelpLayout
 from interfacy.appearance.renderer import (
     SchemaHelpRenderer,
     command_has_grouped_subcommands,
@@ -17,15 +18,13 @@
     from interfacy.schema.schema import Argument, Command, ParserSchema
 
 
-def _uses_template_layout(layout: object) -> bool:
-    layout_mode = getattr(layout, "layout_mode", None)
+def _uses_template_layout(layout: HelpLayout) -> bool:
+    layout_mode = layout.layout_mode
     if layout_mode == "template":
         return True
     if layout_mode == "adaptive":
         return False
-    return bool(
-        getattr(layout, "format_option", None) or getattr(layout, "format_positional", None)
-    )
+    return bool(layout.format_option or layout.format_positional)
 
 
 class InterfacyClickHelpFormatter(click.HelpFormatter):

interfacy/click_backend/parser.py

@@ -56,7 +56,7 @@ def _get_value_from_state(
         option: _OptionLike,
         state: _ParsingStateLike,
     ) -> object:
-        if getattr(option, "nargs", 1) != -1:
+        if option.nargs != -1:
             return super()._get_value_from_state(option_name, option, state)
 
         collected: list[str] = []

interfacy/core.py

@@ -218,7 +218,7 @@ def __init__(
         self.help_position = help_position
         self._help_layout_explicit = help_layout is not None
         self._help_position_explicit = help_position is not None or (
-            help_layout is not None and getattr(help_layout, "help_position", None) is not None
+            help_layout is not None and help_layout.help_position is not None
         )
 
         self.autorun = run
@@ -287,7 +287,8 @@ def _resolve_help_option_sort_from_layout(
             help_layout=help_layout,
             user_value=self.help_option_sort,
             user_validator=validate_help_option_sort,
-            layout_default_attr="help_option_sort_default",
+            layout_default_value=help_layout.help_option_sort_default,
+            layout_default_name="help_option_sort_default",
             layout_resolver=resolve_help_option_sort_rules,
             default_rules=DEFAULT_HELP_OPTION_SORT_RULES,
         )
@@ -298,7 +299,8 @@ def _resolve_help_sort_from_layout(
         help_layout: HelpLayout,
         user_value: object,
         user_validator: Callable[[object], list[SortRuleT] | None],
-        layout_default_attr: str,
+        layout_default_value: object,
+        layout_default_name: str,
         layout_resolver: Callable[..., list[SortRuleT] | None],
         default_rules: Sequence[SortRuleT],
     ) -> list[SortRuleT]:
@@ -307,8 +309,8 @@ def _resolve_help_sort_from_layout(
             return list(user_rules)
 
         layout_rules = layout_resolver(
-            getattr(help_layout, layout_default_attr, None),
-            value_name=f"{help_layout.__class__.__name__}.{layout_default_attr}",
+            layout_default_value,
+            value_name=f"{help_layout.__class__.__name__}.{layout_default_name}",
         )
         if layout_rules:
             return list(layout_rules)
@@ -332,7 +334,8 @@ def _resolve_help_subcommand_sort_from_layout(
             help_layout=help_layout,
             user_value=self.help_subcommand_sort,
             user_validator=validate_help_subcommand_sort,
-            layout_default_attr="help_subcommand_sort_default",
+            layout_default_value=help_layout.help_subcommand_sort_default,
+            layout_default_name="help_subcommand_sort_default",
             layout_resolver=resolve_help_subcommand_sort_rules,
             default_rules=DEFAULT_HELP_SUBCOMMAND_SORT_RULES,
         )

interfacy/schema/builder.py

@@ -126,9 +126,8 @@ def _resolve_help_option_sort_value(
 
         layout = self.parser.help_layout
         if layout is not None:
-            layout_default = getattr(layout, "help_option_sort_default", None)
             layout_rules = resolve_help_option_sort_rules(
-                layout_default,
+                layout.help_option_sort_default,
                 value_name=f"{layout.__class__.__name__}.help_option_sort_default",
             )
             if layout_rules:
@@ -148,9 +147,8 @@ def _resolve_help_subcommand_sort_value(
 
         layout = self.parser.help_layout
         if layout is not None:
-            layout_default = getattr(layout, "help_subcommand_sort_default", None)
             layout_rules = resolve_help_subcommand_sort_rules(
-                layout_default,
+                layout.help_subcommand_sort_default,
                 value_name=f"{layout.__class__.__name__}.help_subcommand_sort_default",
             )
             if layout_rules:
@@ -160,19 +158,19 @@ def _resolve_help_subcommand_sort_value(
 
     def _base_build_settings(self) -> _CommandBuildSettings:
         help_option_sort = self._resolve_help_option_sort_value(
-            getattr(self.parser, "help_option_sort", None),
+            self.parser.help_option_sort,
             value_name="help_option_sort",
         )
         help_subcommand_sort = self._resolve_help_subcommand_sort_value(
-            getattr(self.parser, "help_subcommand_sort", None),
+            self.parser.help_subcommand_sort,
             value_name="help_subcommand_sort",
         )
         return _CommandBuildSettings(
-            include_inherited_methods=getattr(self.parser, "include_inherited_methods", False),
-            include_classmethods=getattr(self.parser, "include_classmethods", False),
-            expand_model_params=getattr(self.parser, "expand_model_params", True),
-            model_expansion_max_depth=getattr(self.parser, "model_expansion_max_depth", 3),
-            abbreviation_scope=getattr(self.parser, "abbreviation_scope", "top_level_options"),
+            include_inherited_methods=self.parser.include_inherited_methods,
+            include_classmethods=self.parser.include_classmethods,
+            expand_model_params=self.parser.expand_model_params,
+            model_expansion_max_depth=self.parser.model_expansion_max_depth,
+            abbreviation_scope=self.parser.abbreviation_scope,
             help_option_sort=help_option_sort,
             help_subcommand_sort=help_subcommand_sort,
         )
@@ -858,7 +856,7 @@ def _argument_from_parameter(
             has_default=param.has_default,
             default=param.default if param.has_default else None,
             is_required=param.is_required,
-            is_optional=getattr(param, "is_optional", False),
+            is_optional=param.is_optional,
             kind=param.kind,
             description=param.description,
         )

interfacy/util.py

@@ -442,19 +442,18 @@ def get_annotation_choices(annotation: object, *, for_display: bool = False) ->
 
 def get_param_choices(param: Parameter, *, for_display: bool = False) -> list[object] | None:
     """Return choices for an objinspect Parameter, falling back to inferred Enum types."""
-    choices = get_annotation_choices(getattr(param, "type", None), for_display=for_display)
+    choices = get_annotation_choices(param.type, for_display=for_display)
     if choices:
         return choices
 
     inferred = None
-    if hasattr(param, "get_infered_type"):
-        try:
-            inferred = param.get_infered_type()
-        except (AttributeError, KeyError, NameError, TypeError, ValueError):
-            inferred = None
+    try:
+        inferred = param.get_infered_type()
+    except (AttributeError, KeyError, NameError, TypeError, ValueError):
+        inferred = None
 
-    if inferred is None and getattr(param, "has_default", False):
-        default = getattr(param, "default", None)
+    if inferred is None and param.has_default:
+        default = param.default
         if isinstance(default, Enum):
             inferred = type(default)
 

tests/common/test_type_help_tokenization.py

@@ -8,7 +8,7 @@
 
 
 def _marker(text: str, style: TextStyle) -> str:
-    color = getattr(style, "color", "none")
+    color = style.color
     return f"<{color}>{text}</{color}>"
 
 

tests/schema/conftest.py

@@ -73,7 +73,7 @@ def make_command_stub(
         canonical_name=canonical,
         cli_name=canonical,
         aliases=tuple(aliases),
-        raw_description=obj.description if hasattr(obj, "description") else None,
+        raw_description=obj.description,
         help_layout=layout,
     )
 
@@ -93,6 +93,8 @@ class FakeParser:
     reserved_flags: Sequence[str] = ("help",)
     command_key: str | None = "command"
     metadata: dict[str, Any] | None = None
+    include_inherited_methods: bool = False
+    include_classmethods: bool = False
     expand_model_params: bool = True
     model_expansion_max_depth: int = 3
     abbreviation_scope: str = "top_level_options"