android-notify 1.60.0__py3-none-any.whl → 1.60.1__py3-none-any.whl

venv/Lib/site-packages/markdown_it/renderer.py

@@ -1,336 +0,0 @@
-"""
-class Renderer
-
-Generates HTML from parsed token stream. Each instance has independent
-copy of rules. Those can be rewritten with ease. Also, you can add new
-rules if you create plugin and adds new token types.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-import inspect
-from typing import Any, ClassVar, Protocol
-
-from .common.utils import escapeHtml, unescapeAll
-from .token import Token
-from .utils import EnvType, OptionsDict
-
-
-class RendererProtocol(Protocol):
-    __output__: ClassVar[str]
-
-    def render(
-        self, tokens: Sequence[Token], options: OptionsDict, env: EnvType
-    ) -> Any: ...
-
-
-class RendererHTML(RendererProtocol):
-    """Contains render rules for tokens. Can be updated and extended.
-
-    Example:
-
-    Each rule is called as independent static function with fixed signature:
-
-    ::
-
-        class Renderer:
-            def token_type_name(self, tokens, idx, options, env) {
-                # ...
-                return renderedHTML
-
-    ::
-
-        class CustomRenderer(RendererHTML):
-            def strong_open(self, tokens, idx, options, env):
-                return '<b>'
-            def strong_close(self, tokens, idx, options, env):
-                return '</b>'
-
-        md = MarkdownIt(renderer_cls=CustomRenderer)
-
-        result = md.render(...)
-
-    See https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js
-    for more details and examples.
-    """
-
-    __output__ = "html"
-
-    def __init__(self, parser: Any = None):
-        self.rules = {
-            k: v
-            for k, v in inspect.getmembers(self, predicate=inspect.ismethod)
-            if not (k.startswith("render") or k.startswith("_"))
-        }
-
-    def render(
-        self, tokens: Sequence[Token], options: OptionsDict, env: EnvType
-    ) -> str:
-        """Takes token stream and generates HTML.
-
-        :param tokens: list on block tokens to render
-        :param options: params of parser instance
-        :param env: additional data from parsed input
-
-        """
-        result = ""
-
-        for i, token in enumerate(tokens):
-            if token.type == "inline":
-                if token.children:
-                    result += self.renderInline(token.children, options, env)
-            elif token.type in self.rules:
-                result += self.rules[token.type](tokens, i, options, env)
-            else:
-                result += self.renderToken(tokens, i, options, env)
-
-        return result
-
-    def renderInline(
-        self, tokens: Sequence[Token], options: OptionsDict, env: EnvType
-    ) -> str:
-        """The same as ``render``, but for single token of `inline` type.
-
-        :param tokens: list on block tokens to render
-        :param options: params of parser instance
-        :param env: additional data from parsed input (references, for example)
-        """
-        result = ""
-
-        for i, token in enumerate(tokens):
-            if token.type in self.rules:
-                result += self.rules[token.type](tokens, i, options, env)
-            else:
-                result += self.renderToken(tokens, i, options, env)
-
-        return result
-
-    def renderToken(
-        self,
-        tokens: Sequence[Token],
-        idx: int,
-        options: OptionsDict,
-        env: EnvType,
-    ) -> str:
-        """Default token renderer.
-
-        Can be overridden by custom function
-
-        :param idx: token index to render
-        :param options: params of parser instance
-        """
-        result = ""
-        needLf = False
-        token = tokens[idx]
-
-        # Tight list paragraphs
-        if token.hidden:
-            return ""
-
-        # Insert a newline between hidden paragraph and subsequent opening
-        # block-level tag.
-        #
-        # For example, here we should insert a newline before blockquote:
-        #  - a
-        #    >
-        #
-        if token.block and token.nesting != -1 and idx and tokens[idx - 1].hidden:
-            result += "\n"
-
-        # Add token name, e.g. `<img`
-        result += ("</" if token.nesting == -1 else "<") + token.tag
-
-        # Encode attributes, e.g. `<img src="foo"`
-        result += self.renderAttrs(token)
-
-        # Add a slash for self-closing tags, e.g. `<img src="foo" /`
-        if token.nesting == 0 and options["xhtmlOut"]:
-            result += " /"
-
-        # Check if we need to add a newline after this tag
-        if token.block:
-            needLf = True
-
-            if token.nesting == 1 and (idx + 1 < len(tokens)):
-                nextToken = tokens[idx + 1]
-
-                if nextToken.type == "inline" or nextToken.hidden:
-                    # Block-level tag containing an inline tag.
-                    #
-                    needLf = False
-
-                elif nextToken.nesting == -1 and nextToken.tag == token.tag:
-                    # Opening tag + closing tag of the same type. E.g. `<li></li>`.
-                    #
-                    needLf = False
-
-        result += ">\n" if needLf else ">"
-
-        return result
-
-    @staticmethod
-    def renderAttrs(token: Token) -> str:
-        """Render token attributes to string."""
-        result = ""
-
-        for key, value in token.attrItems():
-            result += " " + escapeHtml(key) + '="' + escapeHtml(str(value)) + '"'
-
-        return result
-
-    def renderInlineAsText(
-        self,
-        tokens: Sequence[Token] | None,
-        options: OptionsDict,
-        env: EnvType,
-    ) -> str:
-        """Special kludge for image `alt` attributes to conform CommonMark spec.
-
-        Don't try to use it! Spec requires to show `alt` content with stripped markup,
-        instead of simple escaping.
-
-        :param tokens: list on block tokens to render
-        :param options: params of parser instance
-        :param env: additional data from parsed input
-        """
-        result = ""
-
-        for token in tokens or []:
-            if token.type == "text":
-                result += token.content
-            elif token.type == "image":
-                if token.children:
-                    result += self.renderInlineAsText(token.children, options, env)
-            elif token.type == "softbreak":
-                result += "\n"
-
-        return result
-
-    ###################################################
-
-    def code_inline(
-        self, tokens: Sequence[Token], idx: int, options: OptionsDict, env: EnvType
-    ) -> str:
-        token = tokens[idx]
-        return (
-            "<code"
-            + self.renderAttrs(token)
-            + ">"
-            + escapeHtml(tokens[idx].content)
-            + "</code>"
-        )
-
-    def code_block(
-        self,
-        tokens: Sequence[Token],
-        idx: int,
-        options: OptionsDict,
-        env: EnvType,
-    ) -> str:
-        token = tokens[idx]
-
-        return (
-            "<pre"
-            + self.renderAttrs(token)
-            + "><code>"
-            + escapeHtml(tokens[idx].content)
-            + "</code></pre>\n"
-        )
-
-    def fence(
-        self,
-        tokens: Sequence[Token],
-        idx: int,
-        options: OptionsDict,
-        env: EnvType,
-    ) -> str:
-        token = tokens[idx]
-        info = unescapeAll(token.info).strip() if token.info else ""
-        langName = ""
-        langAttrs = ""
-
-        if info:
-            arr = info.split(maxsplit=1)
-            langName = arr[0]
-            if len(arr) == 2:
-                langAttrs = arr[1]
-
-        if options.highlight:
-            highlighted = options.highlight(
-                token.content, langName, langAttrs
-            ) or escapeHtml(token.content)
-        else:
-            highlighted = escapeHtml(token.content)
-
-        if highlighted.startswith("<pre"):
-            return highlighted + "\n"
-
-        # If language exists, inject class gently, without modifying original token.
-        # May be, one day we will add .deepClone() for token and simplify this part, but
-        # now we prefer to keep things local.
-        if info:
-            # Fake token just to render attributes
-            tmpToken = Token(type="", tag="", nesting=0, attrs=token.attrs.copy())
-            tmpToken.attrJoin("class", options.langPrefix + langName)
-
-            return (
-                "<pre><code"
-                + self.renderAttrs(tmpToken)
-                + ">"
-                + highlighted
-                + "</code></pre>\n"
-            )
-
-        return (
-            "<pre><code"
-            + self.renderAttrs(token)
-            + ">"
-            + highlighted
-            + "</code></pre>\n"
-        )
-
-    def image(
-        self,
-        tokens: Sequence[Token],
-        idx: int,
-        options: OptionsDict,
-        env: EnvType,
-    ) -> str:
-        token = tokens[idx]
-
-        # "alt" attr MUST be set, even if empty. Because it's mandatory and
-        # should be placed on proper position for tests.
-        if token.children:
-            token.attrSet("alt", self.renderInlineAsText(token.children, options, env))
-        else:
-            token.attrSet("alt", "")
-
-        return self.renderToken(tokens, idx, options, env)
-
-    def hardbreak(
-        self, tokens: Sequence[Token], idx: int, options: OptionsDict, env: EnvType
-    ) -> str:
-        return "<br />\n" if options.xhtmlOut else "<br>\n"
-
-    def softbreak(
-        self, tokens: Sequence[Token], idx: int, options: OptionsDict, env: EnvType
-    ) -> str:
-        return (
-            ("<br />\n" if options.xhtmlOut else "<br>\n") if options.breaks else "\n"
-        )
-
-    def text(
-        self, tokens: Sequence[Token], idx: int, options: OptionsDict, env: EnvType
-    ) -> str:
-        return escapeHtml(tokens[idx].content)
-
-    def html_block(
-        self, tokens: Sequence[Token], idx: int, options: OptionsDict, env: EnvType
-    ) -> str:
-        return tokens[idx].content
-
-    def html_inline(
-        self, tokens: Sequence[Token], idx: int, options: OptionsDict, env: EnvType
-    ) -> str:
-        return tokens[idx].content

venv/Lib/site-packages/markdown_it/ruler.py

@@ -1,275 +0,0 @@
-"""
-class Ruler
-
-Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and
-[[MarkdownIt#inline]] to manage sequences of functions (rules):
-
-- keep rules in defined order
-- assign the name to each rule
-- enable/disable rules
-- add/replace rules
-- allow assign rules to additional named chains (in the same)
-- caching lists of active rules
-
-You will not need use this class directly until write plugins. For simple
-rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and
-[[MarkdownIt.use]].
-"""
-
-from __future__ import annotations
-
-from collections.abc import Iterable
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Generic, TypedDict, TypeVar
-import warnings
-
-from .utils import EnvType
-
-if TYPE_CHECKING:
-    from markdown_it import MarkdownIt
-
-
-class StateBase:
-    def __init__(self, src: str, md: MarkdownIt, env: EnvType):
-        self.src = src
-        self.env = env
-        self.md = md
-
-    @property
-    def src(self) -> str:
-        return self._src
-
-    @src.setter
-    def src(self, value: str) -> None:
-        self._src = value
-        self._srcCharCode: tuple[int, ...] | None = None
-
-    @property
-    def srcCharCode(self) -> tuple[int, ...]:
-        warnings.warn(
-            "StateBase.srcCharCode is deprecated. Use StateBase.src instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        if self._srcCharCode is None:
-            self._srcCharCode = tuple(ord(c) for c in self._src)
-        return self._srcCharCode
-
-
-class RuleOptionsType(TypedDict, total=False):
-    alt: list[str]
-
-
-RuleFuncTv = TypeVar("RuleFuncTv")
-"""A rule function, whose signature is dependent on the state type."""
-
-
-@dataclass(slots=True)
-class Rule(Generic[RuleFuncTv]):
-    name: str
-    enabled: bool
-    fn: RuleFuncTv = field(repr=False)
-    alt: list[str]
-
-
-class Ruler(Generic[RuleFuncTv]):
-    def __init__(self) -> None:
-        # List of added rules.
-        self.__rules__: list[Rule[RuleFuncTv]] = []
-        # Cached rule chains.
-        # First level - chain name, '' for default.
-        # Second level - diginal anchor for fast filtering by charcodes.
-        self.__cache__: dict[str, list[RuleFuncTv]] | None = None
-
-    def __find__(self, name: str) -> int:
-        """Find rule index by name"""
-        for i, rule in enumerate(self.__rules__):
-            if rule.name == name:
-                return i
-        return -1
-
-    def __compile__(self) -> None:
-        """Build rules lookup cache"""
-        chains = {""}
-        # collect unique names
-        for rule in self.__rules__:
-            if not rule.enabled:
-                continue
-            for name in rule.alt:
-                chains.add(name)
-        self.__cache__ = {}
-        for chain in chains:
-            self.__cache__[chain] = []
-            for rule in self.__rules__:
-                if not rule.enabled:
-                    continue
-                if chain and (chain not in rule.alt):
-                    continue
-                self.__cache__[chain].append(rule.fn)
-
-    def at(
-        self, ruleName: str, fn: RuleFuncTv, options: RuleOptionsType | None = None
-    ) -> None:
-        """Replace rule by name with new function & options.
-
-        :param ruleName: rule name to replace.
-        :param fn: new rule function.
-        :param options: new rule options (not mandatory).
-        :raises: KeyError if name not found
-        """
-        index = self.__find__(ruleName)
-        options = options or {}
-        if index == -1:
-            raise KeyError(f"Parser rule not found: {ruleName}")
-        self.__rules__[index].fn = fn
-        self.__rules__[index].alt = options.get("alt", [])
-        self.__cache__ = None
-
-    def before(
-        self,
-        beforeName: str,
-        ruleName: str,
-        fn: RuleFuncTv,
-        options: RuleOptionsType | None = None,
-    ) -> None:
-        """Add new rule to chain before one with given name.
-
-        :param beforeName: new rule will be added before this one.
-        :param ruleName: new rule will be added before this one.
-        :param fn: new rule function.
-        :param options: new rule options (not mandatory).
-        :raises: KeyError if name not found
-        """
-        index = self.__find__(beforeName)
-        options = options or {}
-        if index == -1:
-            raise KeyError(f"Parser rule not found: {beforeName}")
-        self.__rules__.insert(
-            index, Rule[RuleFuncTv](ruleName, True, fn, options.get("alt", []))
-        )
-        self.__cache__ = None
-
-    def after(
-        self,
-        afterName: str,
-        ruleName: str,
-        fn: RuleFuncTv,
-        options: RuleOptionsType | None = None,
-    ) -> None:
-        """Add new rule to chain after one with given name.
-
-        :param afterName: new rule will be added after this one.
-        :param ruleName: new rule will be added after this one.
-        :param fn: new rule function.
-        :param options: new rule options (not mandatory).
-        :raises: KeyError if name not found
-        """
-        index = self.__find__(afterName)
-        options = options or {}
-        if index == -1:
-            raise KeyError(f"Parser rule not found: {afterName}")
-        self.__rules__.insert(
-            index + 1, Rule[RuleFuncTv](ruleName, True, fn, options.get("alt", []))
-        )
-        self.__cache__ = None
-
-    def push(
-        self, ruleName: str, fn: RuleFuncTv, options: RuleOptionsType | None = None
-    ) -> None:
-        """Push new rule to the end of chain.
-
-        :param ruleName: new rule will be added to the end of chain.
-        :param fn: new rule function.
-        :param options: new rule options (not mandatory).
-
-        """
-        self.__rules__.append(
-            Rule[RuleFuncTv](ruleName, True, fn, (options or {}).get("alt", []))
-        )
-        self.__cache__ = None
-
-    def enable(
-        self, names: str | Iterable[str], ignoreInvalid: bool = False
-    ) -> list[str]:
-        """Enable rules with given names.
-
-        :param names: name or list of rule names to enable.
-        :param ignoreInvalid: ignore errors when rule not found
-        :raises: KeyError if name not found and not ignoreInvalid
-        :return: list of found rule names
-        """
-        if isinstance(names, str):
-            names = [names]
-        result: list[str] = []
-        for name in names:
-            idx = self.__find__(name)
-            if (idx < 0) and ignoreInvalid:
-                continue
-            if (idx < 0) and not ignoreInvalid:
-                raise KeyError(f"Rules manager: invalid rule name {name}")
-            self.__rules__[idx].enabled = True
-            result.append(name)
-        self.__cache__ = None
-        return result
-
-    def enableOnly(
-        self, names: str | Iterable[str], ignoreInvalid: bool = False
-    ) -> list[str]:
-        """Enable rules with given names, and disable everything else.
-
-        :param names: name or list of rule names to enable.
-        :param ignoreInvalid: ignore errors when rule not found
-        :raises: KeyError if name not found and not ignoreInvalid
-        :return: list of found rule names
-        """
-        if isinstance(names, str):
-            names = [names]
-        for rule in self.__rules__:
-            rule.enabled = False
-        return self.enable(names, ignoreInvalid)
-
-    def disable(
-        self, names: str | Iterable[str], ignoreInvalid: bool = False
-    ) -> list[str]:
-        """Disable rules with given names.
-
-        :param names: name or list of rule names to enable.
-        :param ignoreInvalid: ignore errors when rule not found
-        :raises: KeyError if name not found and not ignoreInvalid
-        :return: list of found rule names
-        """
-        if isinstance(names, str):
-            names = [names]
-        result = []
-        for name in names:
-            idx = self.__find__(name)
-            if (idx < 0) and ignoreInvalid:
-                continue
-            if (idx < 0) and not ignoreInvalid:
-                raise KeyError(f"Rules manager: invalid rule name {name}")
-            self.__rules__[idx].enabled = False
-            result.append(name)
-        self.__cache__ = None
-        return result
-
-    def getRules(self, chainName: str = "") -> list[RuleFuncTv]:
-        """Return array of active functions (rules) for given chain name.
-        It analyzes rules configuration, compiles caches if not exists and returns result.
-
-        Default chain name is `''` (empty string). It can't be skipped.
-        That's done intentionally, to keep signature monomorphic for high speed.
-
-        """
-        if self.__cache__ is None:
-            self.__compile__()
-            assert self.__cache__ is not None
-        # Chain can be empty, if rules disabled. But we still have to return Array.
-        return self.__cache__.get(chainName, []) or []
-
-    def get_all_rules(self) -> list[str]:
-        """Return all available rule names."""
-        return [r.name for r in self.__rules__]
-
-    def get_active_rules(self) -> list[str]:
-        """Return the active rule names."""
-        return [r.name for r in self.__rules__ if r.enabled]

venv/Lib/site-packages/markdown_it/rules_block/__init__.py

@@ -1,27 +0,0 @@
-__all__ = (
-    "StateBlock",
-    "blockquote",
-    "code",
-    "fence",
-    "heading",
-    "hr",
-    "html_block",
-    "lheading",
-    "list_block",
-    "paragraph",
-    "reference",
-    "table",
-)
-
-from .blockquote import blockquote
-from .code import code
-from .fence import fence
-from .heading import heading
-from .hr import hr
-from .html_block import html_block
-from .lheading import lheading
-from .list import list_block
-from .paragraph import paragraph
-from .reference import reference
-from .state_block import StateBlock
-from .table import table