File Manager

X7ROOT File Manager

Current Path: /opt/cloudlinux/venv/lib/python3.11/site-packages/pip/_vendor/rich

opt / cloudlinux / venv / lib / python3.11 / site-packages / pip / _vendor / rich /

?? ..
?? __init__.py(5.95 KB)
?? __main__.py(8.28 KB)
?? __pycache__
?? _cell_widths.py(9.97 KB)
?? _emoji_codes.py(136.95 KB)
?? _emoji_replace.py(1.04 KB)
?? _export_format.py(2.08 KB)
?? _extension.py(265 B)
?? _fileno.py(799 B)
?? _inspect.py(9.43 KB)
?? _log_render.py(3.15 KB)
?? _loop.py(1.21 KB)
?? _null_file.py(1.36 KB)
?? _palettes.py(6.9 KB)
?? _pick.py(423 B)
?? _ratio.py(5.34 KB)
?? _spinners.py(19.45 KB)
?? _stack.py(351 B)
?? _timer.py(417 B)
?? _win32_console.py(22.22 KB)
?? _windows.py(1.88 KB)
?? _windows_renderer.py(2.72 KB)
?? _wrap.py(3.32 KB)
?? abc.py(890 B)
?? align.py(10.22 KB)
?? ansi.py(6.76 KB)
?? bar.py(3.19 KB)
?? box.py(10.58 KB)
?? cells.py(5.01 KB)
?? color.py(17.78 KB)
?? color_triplet.py(1.03 KB)
?? columns.py(6.96 KB)
?? console.py(97.81 KB)
?? constrain.py(1.26 KB)
?? containers.py(5.37 KB)
?? control.py(6.47 KB)
?? default_styles.py(7.97 KB)
?? diagnose.py(972 B)
?? emoji.py(2.44 KB)
?? errors.py(642 B)
?? file_proxy.py(1.64 KB)
?? filesize.py(2.43 KB)
?? highlighter.py(9.36 KB)
?? json.py(4.91 KB)
?? jupyter.py(3.18 KB)
?? layout.py(13.68 KB)
?? live.py(13.94 KB)
?? live_render.py(3.58 KB)
?? logging.py(12.17 KB)
?? markup.py(8.25 KB)
?? measure.py(5.18 KB)
?? padding.py(4.79 KB)
?? pager.py(828 B)
?? palette.py(3.32 KB)
?? panel.py(10.97 KB)
?? pretty.py(35.54 KB)
?? progress.py(58.94 KB)
?? progress_bar.py(7.97 KB)
?? prompt.py(12.16 KB)
?? protocol.py(1.36 KB)
?? py.typed(0 B)
?? region.py(166 B)
?? repr.py(4.33 KB)
?? rule.py(4.49 KB)
?? scope.py(2.78 KB)
?? screen.py(1.55 KB)
?? segment.py(24.16 KB)
?? spinner.py(4.26 KB)
?? status.py(4.32 KB)
?? style.py(26.43 KB)
?? styled.py(1.23 KB)
?? syntax.py(34.92 KB)
?? table.py(39.16 KB)
?? terminal_theme.py(3.29 KB)
?? text.py(46.44 KB)
?? theme.py(3.68 KB)
?? themes.py(102 B)
?? traceback.py(31.05 KB)
?? tree.py(9.23 KB)

Editing: markup.py

import re
from ast import literal_eval
from operator import attrgetter
from typing import Callable, Iterable, List, Match, NamedTuple, Optional, Tuple, Union

from ._emoji_replace import _emoji_replace
from .emoji import EmojiVariant
from .errors import MarkupError
from .style import Style
from .text import Span, Text

RE_TAGS = re.compile(
    r"""((\\*)\[([a-z#/@][^[]*?)])""",
    re.VERBOSE,
)

RE_HANDLER = re.compile(r"^([\w.]*?)($.*?$)?$")

class Tag(NamedTuple):
    """A tag in console markup."""

name: str
    """The tag name. e.g. 'bold'."""
    parameters: Optional[str]
    """Any additional parameters after the name."""

def __str__(self) -> str:
        return (
            self.name if self.parameters is None else f"{self.name} {self.parameters}"
        )

@property
    def markup(self) -> str:
        """Get the string representation of this tag."""
        return (
            f"[{self.name}]"
            if self.parameters is None
            else f"[{self.name}={self.parameters}]"
        )

_ReStringMatch = Match[str]  # regex match object
_ReSubCallable = Callable[[_ReStringMatch], str]  # Callable invoked by re.sub
_EscapeSubMethod = Callable[[_ReSubCallable, str], str]  # Sub method of a compiled re

def escape(
    markup: str,
    _escape: _EscapeSubMethod = re.compile(r"(\\*)(\[[a-z#/@][^[]*?])").sub,
) -> str:
    """Escapes text so that it won't be interpreted as markup.

Args:
        markup (str): Content to be inserted in to markup.

Returns:
        str: Markup with square brackets escaped.
    """

def escape_backslashes(match: Match[str]) -> str:
        """Called by re.sub replace matches."""
        backslashes, text = match.groups()
        return f"{backslashes}{backslashes}\\{text}"

markup = _escape(escape_backslashes, markup)
    if markup.endswith("\\") and not markup.endswith("\\\\"):
        return markup + "\\"

return markup

def _parse(markup: str) -> Iterable[Tuple[int, Optional[str], Optional[Tag]]]:
    """Parse markup in to an iterable of tuples of (position, text, tag).

Args:
        markup (str): A string containing console markup

"""
    position = 0
    _divmod = divmod
    _Tag = Tag
    for match in RE_TAGS.finditer(markup):
        full_text, escapes, tag_text = match.groups()
        start, end = match.span()
        if start > position:
            yield start, markup[position:start], None
        if escapes:
            backslashes, escaped = _divmod(len(escapes), 2)
            if backslashes:
                # Literal backslashes
                yield start, "\\" * backslashes, None
                start += backslashes * 2
            if escaped:
                # Escape of tag
                yield start, full_text[len(escapes) :], None
                position = end
                continue
        text, equals, parameters = tag_text.partition("=")
        yield start, None, _Tag(text, parameters if equals else None)
        position = end
    if position < len(markup):
        yield position, markup[position:], None

def render(
    markup: str,
    style: Union[str, Style] = "",
    emoji: bool = True,
    emoji_variant: Optional[EmojiVariant] = None,
) -> Text:
    """Render console markup in to a Text instance.

Args:
        markup (str): A string containing console markup.
        style: (Union[str, Style]): The style to use.
        emoji (bool, optional): Also render emoji code. Defaults to True.
        emoji_variant (str, optional): Optional emoji variant, either "text" or "emoji". Defaults to None.

Raises:
        MarkupError: If there is a syntax error in the markup.

Returns:
        Text: A test instance.
    """
    emoji_replace = _emoji_replace
    if "[" not in markup:
        return Text(
            emoji_replace(markup, default_variant=emoji_variant) if emoji else markup,
            style=style,
        )
    text = Text(style=style)
    append = text.append
    normalize = Style.normalize

style_stack: List[Tuple[int, Tag]] = []
    pop = style_stack.pop

spans: List[Span] = []
    append_span = spans.append

_Span = Span
    _Tag = Tag

def pop_style(style_name: str) -> Tuple[int, Tag]:
        """Pop tag matching given style name."""
        for index, (_, tag) in enumerate(reversed(style_stack), 1):
            if tag.name == style_name:
                return pop(-index)
        raise KeyError(style_name)

for position, plain_text, tag in _parse(markup):
        if plain_text is not None:
            # Handle open brace escapes, where the brace is not part of a tag.
            plain_text = plain_text.replace("\\[", "[")
            append(emoji_replace(plain_text) if emoji else plain_text)
        elif tag is not None:
            if tag.name.startswith("/"):  # Closing tag
                style_name = tag.name[1:].strip()

if style_name:  # explicit close
                    style_name = normalize(style_name)
                    try:
                        start, open_tag = pop_style(style_name)
                    except KeyError:
                        raise MarkupError(
                            f"closing tag '{tag.markup}' at position {position} doesn't match any open tag"
                        ) from None
                else:  # implicit close
                    try:
                        start, open_tag = pop()
                    except IndexError:
                        raise MarkupError(
                            f"closing tag '[/]' at position {position} has nothing to close"
                        ) from None

if open_tag.name.startswith("@"):
                    if open_tag.parameters:
                        handler_name = ""
                        parameters = open_tag.parameters.strip()
                        handler_match = RE_HANDLER.match(parameters)
                        if handler_match is not None:
                            handler_name, match_parameters = handler_match.groups()
                            parameters = (
                                "()" if match_parameters is None else match_parameters
                            )

try:
                            meta_params = literal_eval(parameters)
                        except SyntaxError as error:
                            raise MarkupError(
                                f"error parsing {parameters!r} in {open_tag.parameters!r}; {error.msg}"
                            )
                        except Exception as error:
                            raise MarkupError(
                                f"error parsing {open_tag.parameters!r}; {error}"
                            ) from None

if handler_name:
                            meta_params = (
                                handler_name,
                                meta_params
                                if isinstance(meta_params, tuple)
                                else (meta_params,),
                            )

else:
                        meta_params = ()

append_span(
                        _Span(
                            start, len(text), Style(meta={open_tag.name: meta_params})
                        )
                    )
                else:
                    append_span(_Span(start, len(text), str(open_tag)))

else:  # Opening tag
                normalized_tag = _Tag(normalize(tag.name), tag.parameters)
                style_stack.append((len(text), normalized_tag))

text_length = len(text)
    while style_stack:
        start, tag = style_stack.pop()
        style = str(tag)
        if style:
            append_span(_Span(start, text_length, style))

text.spans = sorted(spans[::-1], key=attrgetter("start"))
    return text

if __name__ == "__main__":  # pragma: no cover
    MARKUP = [
        "[red]Hello World[/red]",
        "[magenta]Hello [b]World[/b]",
        "[bold]Bold[italic] bold and italic [/bold]italic[/italic]",
        "Click [link=https://www.willmcgugan.com]here[/link] to visit my Blog",
        ":warning-emoji: [bold red blink] DANGER![/]",
    ]

from pip._vendor.rich import print
    from pip._vendor.rich.table import Table

grid = Table("Markup", "Result", padding=(0, 1))

for markup in MARKUP:
        grid.add_row(Text(markup), markup)

print(grid)

X7ROOT File Manager

Editing: markup.py

Upload File

Create Folder