mrml-python 0.2.0

Python wrapping on MRML
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

from typing import Any, Dict, List, Optional, Set, Union

class NoopIncludeLoaderOptions:
    """No-operation loader options class, which requires no specific configuration."""

    pass

class MemoryIncludeLoaderOptions:
    """MemoryIncludeLoaderOptions stores mappings for in-memory data using a dictionary."""
    def __init__(self, data: Dict[str, str]) -> None: ...

class LocalIncludeLoaderOptions:
    """LocalIncludeLoaderOptions configures a loader with a filesystem path."""
    def __init__(self, path: str) -> None: ...

class HttpIncludeLoaderOptionsMode:
    """HttpIncludeLoaderOptionsMode is an enumeration for HTTP loader behavior modes."""

    Allow: "HttpIncludeLoaderOptionsMode"
    Deny: "HttpIncludeLoaderOptionsMode"

class HttpIncludeLoaderOptions:
    """HttpIncludeLoaderOptions defines options for an HTTP include loader, including mode and a list of URLs."""
    def __init__(self, mode: HttpIncludeLoaderOptionsMode, list: Set[str]) -> None: ...

class ParserIncludeLoaderOptions:
    """ParserIncludeLoaderOptions is a union type that can represent any type of include loader options."""
    def __init__(
        self,
        loader: Union[
            NoopIncludeLoaderOptions,
            MemoryIncludeLoaderOptions,
            LocalIncludeLoaderOptions,
            HttpIncludeLoaderOptions,
        ],
    ) -> None: ...
    def build(self) -> Any:
        """Build method constructs the actual loader object, might return different types based on the loader configuration."""
        ...

def noop_loader() -> ParserIncludeLoaderOptions:
    """Factory function to create a no-operation loader."""
    ...

def memory_loader(data: Optional[Dict[str, str]] = None) -> ParserIncludeLoaderOptions:
    """Factory function to create a memory loader with optional data."""
    ...

def local_loader(data: Optional[str] = None) -> ParserIncludeLoaderOptions:
    """Factory function to create a local loader, converting a string path to a Path object internally."""
    ...

def http_loader(
    mode: Optional[HttpIncludeLoaderOptionsMode] = None, list: Optional[Set[str]] = None
) -> ParserIncludeLoaderOptions:
    """Factory function to create an HTTP loader with optional mode and list of URLs."""
    ...

class ParserOptions:
    """ParserOptions configures parser behavior, primarily by specifying the include loader to use."""
    def __init__(
        self, include_loader: Optional[ParserIncludeLoaderOptions] = None
    ) -> None: ...

class RenderOptions:
    """RenderOptions configures rendering behavior, including whether to disable comments and how to handle social icons and fonts."""
    def __init__(
        self,
        disable_comments: bool = False,
        social_icon_origin: str | None = None,
        fonts: Dict[str, str] | None = None,
    ) -> None: ...
    @property
    def disable_comments(self) -> bool: ...
    @property
    def social_icon_origin(self) -> str | None: ...
    @property
    def fonts(self) -> Dict[str, str] | None: ...

class Warning:
    @property
    def origin(self) -> Optional[str]: ...
    @property
    def kind(self) -> str: ...
    @property
    def start(self) -> int: ...
    @property
    def end(self) -> int: ...

class Output:
    """to_html result, containing content field and warnings"""
    @property
    def content(self) -> str: ...
    @property
    def warnings(self) -> List[Warning]: ...
    def __init__(self) -> None: ...

def to_html(
    input: str,
    parser_options: Optional[ParserOptions] = None,
    render_options: Optional[RenderOptions] = None,
) -> Output:
    """Function to convert input a MJML string to HTML using optional parser and render configurations."""
    ...