Skip to content

Attribute

AttributeProccessor

Processes a list of Attribute objects and converts them into HTML-formatted attributes.

Attributes:

Name Type Description
attrKeyWords dict

Maps Python keywords to HTML attribute names. - "styles": Translates to "class". - "class_": Translates to "class" (avoids conflict with Python's class keyword). - "for_": Translates to "for". - "name_": Translates to "name". - "type_": Translates to "type".
attrValueWords dict

Maps Python boolean values to HTML-compliant strings. - "True": Translates to "true". - "False": Translates to "false".
Source code in zenaura/client/compiler/attribute.py 
 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
class AttributeProccessor():
    """
        Processes a list of `Attribute` objects and converts them into HTML-formatted attributes.

        Attributes:
            attrKeyWords (dict): Maps Python keywords to HTML attribute names.
                - "styles": Translates to "class".
                - "class_": Translates to "class" (avoids conflict with Python's `class` keyword).
                - "for_": Translates to "for".
                - "name_": Translates to "name".
                - "type_": Translates to "type".

            attrValueWords (dict): Maps Python boolean values to HTML-compliant strings.
                - "True": Translates to "true".
                - "False": Translates to "false".

        Methods:
            None
    """
    def __init__(self):
        self.attrKeyWords = {
            "styles": "class",
            "class_": "class",
            "for_": "for",
            "name_": "name",
            "type_": "type"
        }
        self.attrValueWords = {
            "True": "true",
            "False": "false"
        }
    def process_attributes(
                self, 
                attrs: List[Attribute]
                ) -> str:
        """
        Processes a list of `Attribute` objects, converting them to HTML-formatted attributes.

        Args:
            attrs (List[Attribute]): A list of `Attribute` objects representing the attributes to be processed.

        Returns:
            str: A string containing the HTML-formatted attributes, ready to be included in a tag.

        Raises:
            TypeError: If the input `attrs` is not a list.
            ValueError: If any element in `attrs` is not an `Attribute` object.
        """

        if not isinstance(attrs, list):
            raise TypeError("`attrs` must be a list of Attribute objects.")

        for attr in attrs:
            if not isinstance(attr, Attribute):
                raise ValueError("Each element in `attrs` must be an Attribute object.")

        s = io.StringIO()  # Create a string buffer for building the output

        for i, attr in enumerate(attrs):
            attrKey = attr.key
            attrValue = attr.value
            if attrKey in self.attrKeyWords.keys():
                attrKey = self.attrKeyWords[attrKey]  # Apply keyword mapping
            if str(attrValue) in self.attrValueWords.keys():
                attrValue = self.attrValueWords[str(attrValue)]

            # Add space only if it's not the first or last attribute
            if i == 0 or i == len(attrs) - 1:
                s.write(f' {attrKey}="{sanitizer.sanitize(attrValue)}"')
            else:
                s.write(f'{attrKey}="{sanitizer.sanitize(attrValue)}" ')

        res = s.getvalue()
        s.close()
        return res

process_attributes(attrs)

Processes a list of Attribute objects, converting them to HTML-formatted attributes.

Parameters:

Name Type Description Default
attrs List[Attribute]

A list of Attribute objects representing the attributes to be processed.

 required

Returns:

Name Type Description
str str

A string containing the HTML-formatted attributes, ready to be included in a tag.

Raises:

Type Description
TypeError

If the input attrs is not a list.
ValueError

If any element in attrs is not an Attribute object.
Source code in zenaura/client/compiler/attribute.py 
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
def process_attributes(
            self, 
            attrs: List[Attribute]
            ) -> str:
    """
    Processes a list of `Attribute` objects, converting them to HTML-formatted attributes.

    Args:
        attrs (List[Attribute]): A list of `Attribute` objects representing the attributes to be processed.

    Returns:
        str: A string containing the HTML-formatted attributes, ready to be included in a tag.

    Raises:
        TypeError: If the input `attrs` is not a list.
        ValueError: If any element in `attrs` is not an `Attribute` object.
    """

    if not isinstance(attrs, list):
        raise TypeError("`attrs` must be a list of Attribute objects.")

    for attr in attrs:
        if not isinstance(attr, Attribute):
            raise ValueError("Each element in `attrs` must be an Attribute object.")

    s = io.StringIO()  # Create a string buffer for building the output

    for i, attr in enumerate(attrs):
        attrKey = attr.key
        attrValue = attr.value
        if attrKey in self.attrKeyWords.keys():
            attrKey = self.attrKeyWords[attrKey]  # Apply keyword mapping
        if str(attrValue) in self.attrValueWords.keys():
            attrValue = self.attrValueWords[str(attrValue)]

        # Add space only if it's not the first or last attribute
        if i == 0 or i == len(attrs) - 1:
            s.write(f' {attrKey}="{sanitizer.sanitize(attrValue)}"')
        else:
            s.write(f'{attrKey}="{sanitizer.sanitize(attrValue)}" ')

    res = s.getvalue()
    s.close()
    return res