Bug: Rich help doesn't respect environment variable TYPER_USE_RICH during tab completion.

[albin-paul-saju]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the Typer documentation, with the integrated search.
• I already searched in Google "How to X in Typer" and didn't find any information.
• I already read and followed all the tutorials in the docs and didn't find an answer.
• I already checked if it is not related to Typer but to Click.

Commit to Help

• I commit to help with one of those options 👆

Example Code

import importlib.machinery
import sys
import types

import typer

GUARDED_MODULES = {'rich'}

class _GuardedObject:
    __slots__ = ('_go_module_name', '_go_attr_name')

    def __init__(self, module_name, attr_name):
        self._go_module_name = module_name
        self._go_attr_name = attr_name

    def _go_raise_violation(self, operation: str):
        raise RuntimeError(
            f"\n{'='*70}\nIMPORT GUARD VIOLATION\n{'='*70}\n"
            f"Operation: {operation}\n"
            f"Guarded object: {self._go_module_name}.{self._go_attr_name}\n\n"
            f"A heavy module was accessed during --help or tab completion.\n"
            f"This will significantly slow down CLI startup time.\n\n"
            f"Solution:\n"
            f"1. Move the import inside the function that uses it\n"
            f"2. Use TYPE_CHECKING for type hints\n"
            f"3. Avoid using this object at module load time\n"
            f"{'='*70}"
        )

    def __call__(self, *args, **kwargs):
        self._go_raise_violation(f"calling {self._go_module_name}.{self._go_attr_name}()")

    def __getattr__(self, name):
        if not (name.startswith('__') and name.endswith('__')):
            self._go_raise_violation(f"accessing attribute '{name}' on {self._go_module_name}.{self._go_attr_name}")
        raise AttributeError(name)

    def __setattr__(self, name, value):
        if name.startswith('_go_'):
            object.__setattr__(self, name, value)
        else:
            self._go_raise_violation(f"setting attribute '{name}' on {self._go_module_name}.{self._go_attr_name}")

    def __repr__(self):
        return f"<Guarded {self._go_module_name}.{self._go_attr_name}>"

    def __class_getitem__(cls, item):
        return cls

    def __mro_entries__(self, _):
        return self._go_raise_violation(f"inheriting from {self._go_module_name}.{self._go_attr_name}")

    def __getitem__(self, key):
        self._go_raise_violation(f"Accessing {self._go_module_name}.{self._go_attr_name}[{key}]")

    def __iter__(self):
        return self._go_raise_violation(f"iterating over {self._go_module_name}.{self._go_attr_name}")

    def __len__(self):
        return self._go_raise_violation(f"getting length of {self._go_module_name}.{self._go_attr_name}")

    def __bool__(self):
        return self._go_raise_violation(f"evaluating truthiness of {self._go_module_name}.{self._go_attr_name}")

    def __instancecheck__(self, instance):
        return self._go_raise_violation(f"isinstance() check with {self._go_module_name}.{self._go_attr_name}")

    def __subclasscheck__(self, subclass):
        return self._go_raise_violation(f"issubclass() check with {self._go_module_name}.{self._go_attr_name}")


class _GuardedModuleProxy(types.ModuleType):
    def __getattr__(self, name):
        if name not in self.__dict__.setdefault('_guarded_attrs', {}):
            self.__dict__['_guarded_attrs'][name] = _GuardedObject(self.__name__, name)
        return self.__dict__['_guarded_attrs'][name]

    def __repr__(self):
        return f"<Guarded module '{self.__name__}'>"


class _ImportGuardLoader:
    def create_module(self, spec):
        return _GuardedModuleProxy(spec.name)

    def exec_module(self, module):
        module.__path__ = []
        module.__package__ = module.__name__


class _ImportGuardFinder:
    def find_spec(self, fullname, path, target=None):
        if fullname.split('.')[0] not in GUARDED_MODULES:
            return None
        return importlib.machinery.ModuleSpec(fullname, _guard_loader, is_package=True)

import os
os.environ["TYPER_USE_RICH"]="false"
_guard_loader = _ImportGuardLoader()
sys.meta_path.insert(0, _ImportGuardFinder())

app = typer.Typer()

@app.command()
def main(name: str):
    typer.echo("hello")

app()

Description

I wanted to make typer import time very fast for tab completions around 250ms.
So I replaced rich with a dummy module by overloading importlib.machinery.ModuleSpec.
And made sure that rich is not at imported at all when I set TYPER_USE_RICH="false".
This environment variable is not considered at code.
So I had to monkey patch find_spec.
Please consider the variable there.

Operating System

Linux

Operating System Details

No response

Typer Version

0.24.1

Python Version

Python 3.12.12

Additional Context

No response

[svlandeg]

Thanks for the note - that does look like a bug and I'll look into it!

[albin-paul-saju]

@svlandeg I have created a PR for this. Could you please review this? Thanks for the response.