Alternate rendering for links?

[ronf]

I've been thinking about starting to use the "link" style to add hyperlinks to some output, but I'd like to provide an alternate rendering of the text when on terminals that don't support them. Instead of just outputting the main text and throwing away the URL, I'm thinking of rendering it as something like "label (url)", e.g. "Google (https://www.google.com/)".

What makes this a bit tricky is that the text which contains the markup is entered by one user but then displayed later to another user who may have different terminal capabilities. So, I'd like to make the decision of what to display at rendering time. I'd also like to avoid need to parse the marked-up text myself looking for [link] tags.

Is there a straightforward way to provide an alternate renderer to what's in the style class? It seems like there might be a way to do it with a class that implements rich_console and wraps around a renderable, but I'd want it to be able to handle things like text with a link inside a table, running on the table cells before the table is rendered so that the wider version of the text with the visible URL is taken into account.

[willmcgugan]

Hi @ronf

There is no obvious hook in Rich were you could enable that behaviour globally.

Your idea re a custom renderable is sound. If you were to create a class that contained raw markup you could decide how it should look at the point of render. You could use that anywhere in Rich, including table cells. You would also need to implement a __rich_measure__ method so that Rich can calculate optimal column sizes. There are plenty examples in the repos of the measure methods.

As for actually generating the LABEL (URL) text, you could customize markup.py or maybe post-process the text instance. Both would require dipping in to the Rich internals I'm afraid.

I'll have a think about a way to make that easier. Maybe Rich could offer that behaviour, or at least make it easy to extend how markup is rendered. No promises on timescale...

Will

[willmcgugan]

This code will expand links. I may add this as a method on the Text class...

from rich.console import Console
from rich.style import StyleType
from rich.text import Text


def expand_links(console: Console, text: Text, link_style: StyleType) -> Text:
    result = text.blank_copy()

    def gen_tokens(text):
        render = list(text.render(console))
        pairs = zip(render, render[1:] + [("", None, False)])
        for (text, style, _), (_, style2, _) in pairs:
            if style.link and style2.link != style.link:
                yield text, style.update_link(None)
                yield " (", None
                yield style.link, link_style
                yield ")", None
            else:
                yield text, style

    result.append_tokens(gen_tokens(text))
    return result


example = Text.from_markup(
    """Visit [link=https://www.google.com]Google[/link] to search."""
)

console = Console()
console.print(example)
console.print(expand_links(console, example, "underline blue"))

[ronf]

Thank you so much! I continue to be impressed by how flexible the framework you've built here is!

I ran into a problem here with it not liking None on the yields related to adding the parentheses. Changing that from None to "none" fixed the problem. However, I also wanted to be able to preserve the original style on the text for the parentheses, and only incrementally modify that style for the link inside the parentheses. I also wanted to do this conversion whenever there was a link, even if the style wasn't changing. That was important, as otherwise the text of the link itself still gets lost. Doing that actually simplified the code somewhat, too. Here's what I ended up with:

def expand_links(console: Console, text: Text, link_style: StyleType) -> Text:
    result = text.blank_copy()

    def gen_tokens(text):
        render = list(text.render(console))
        for text, style, _ in render:
            if style.link and text != style.link:
                yield text, style.update_link(None)
                yield " (", style
                yield style.link, f'{style} {link_style}'
                yield ")", style
            else:
                yield text, style

    result.append_tokens(gen_tokens(text))
    return result

This lets me do things like have the "underline blue" on the label in the non-expanded version of the link and keep it for the expanded version (with optional modifications).

I'm not sure if there's a better way to incrementally update the style than using f'{style} {link_style}', but that seems to work.

[ronf]

Playing with this a bit more, I think it probably makes sense to do a check here like if style.link and text != style.link to see if the link and the label are identical, and in that case not do the expansion. I'll edit my previous response to reflect that.

[willmcgugan]

There is an edge case here. Not sure if it affects you. Consider this bit of markup:

"Visit [link=https://google.com]G[bold]oo[/bold]gle.com[/link]"

The Text.render method will break the link text in to pieces around the bold "oo". You probably don't want to add (https://google.com) to each segment.

I'm not sure if there's a better way to incrementally update the style than using f'{style} {link_style}', but that seems to work.

That works! I'd never considered doing it that way. You can avoid the overhead of parsing by adding Style objects, e.g.:

style + console.get_style(link_style)

[ronf]

Thanks - I figured there was probably a more efficient way to do the incremental styling. I moved the call to console.get_style() out of the loop so that the parsing of the incremental style is done only once, ending up with:

def expand_links(console: Console, text: Text, link_style: StyleType = "") -> Text:
    link_style = console.get_style(link_style)
    result = text.blank_copy()

    def gen_tokens(text):
        render = list(text.render(console))
        pairs = zip(render, render[1:] + [("", None, False)])
        for (text, style, _), (_, style2, _) in pairs:
            if style.link and style2.link != style.link and text != style.link:
                yield text, style.update_link(None)
                yield " (", style
                yield style.link, style + link_style
                yield ")", style
            else:
                yield text, style

    result.append_tokens(gen_tokens(text))
    return result

This puts back the check you had about style2.link != style.link, to deal with the edge case you mentioned. That's probably not a case I'll run into, but a more general solution should definitely include it. When additional styles are added like that, the check I added for text != style.link won't work, but I think that's ok. In cases where the text matches the link, I think it's very unlikely that the text will have any embedded styling.

The specific case I'm going after there is the ability to print out a link which might be wrapped onto multiple lines due to width restrictions, but such that all of the pieces of that end up with a link to the full URL. For example, this seems to work:

example = Text.from_markup("[green]Visit [underline blue link=https://www.google.com/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx]https://www.google.com/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx[/underline blue link] to search.")

console = Console()
t = Table(Column("column1", overflow="fold"), "column2")
t.add_row(expand_links(console, example, "reverse"), "abc")
console.print(t)

In this case, the text and link match, so expand_links() doesn't show the text twice. However, the URL is long enough to fold onto multiple lines and each piece links to the full URL. Without adding the [link] around the URL text, the terminal might recognize that there's a URL present (at least for the first piece) and try to make it clickable, but it wouldn't deal properly with the wrap.

[ronf]

After a bit more experimenting here, I realized I wanted something slightly different, where I add the parenthesized link as before but both the original label and the visible version of the URL should both remain links on terminals that support those. Only the space and parentheses should be rendered without the link. The end result looks something like:

def expand_links(console: Console, text: Text) -> Text:
    result = text.blank_copy()

    def gen_tokens(text):
        render = list(text.render(console))
        pairs = zip(render, render[1:] + [("", Style(), False)])
        for (text, style, _), (_, style2, _) in pairs:
            yield text, style

            if style.link and style2.link != style.link and text != style.link:
                no_link_style = style.update_link(None)
                yield " (", no_link_style
                yield style.link, style
                yield ")", no_link_style

    result.append_tokens(gen_tokens(text))
    return result

Note also the use of Style() in the zip call -- it didn't work right with a None there when trying to compare style2.link.