Skip to content

Builder

Builder

A builder class for constructing HTML tags.

This class provides a fluent interface for creating HTML tags with attributes, children, and styles. It simplifies the process of building complex HTML structures.

Attributes:

Name Type Description
node Node

The root node of the tag being built.
Source code in zenaura/client/tags/builder.py 
  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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
class Builder:
    """
    A builder class for constructing HTML tags.

    This class provides a fluent interface for creating HTML tags with attributes,
    children, and styles. It simplifies the process of building complex HTML structures.

    Attributes:
        node (Node): The root node of the tag being built.
    """

    def __init__(self, name: str = "div") -> None:
        """
        Initializes a Builder object with the given tag name.

        Args:
            name (str, optional): The name of the tag. Defaults to "div".
        """
        self.node = Node(name)

    def with_attributes(self, **kwargs) -> "Builder":
        """
        Adds attributes to the tag.

        Args:
            **kwargs: Key-value pairs of attributes.

        Returns:
            Builder: The Builder object.
        """
        for key, value in kwargs.items():
            self.with_attribute(key, value)
        return self

    def with_children(self, *children) -> "Builder":
        """
        Adds child nodes to the tag.

        Args:
            *children: List of child nodes.

        Returns:
            Builder: The Builder object.
        """
        for child in children:
            self.with_child(child)
        return self

    def with_attribute(self, key: str, value: any) -> "Builder":
        """
        Adds an attribute to the tag.

        Args:
            key (str): The key of the attribute.
            value: The value of the attribute.

        Returns:
            Builder: The Builder object.
        """
        self.node.attributes.append(Attribute(key, value))
        return self

    def with_child(self, child: Node) -> "Builder":
        """
        Adds a child node to the tag.

        Args:
            child (Node): The child node to be added.

        Returns:
            Builder: The Builder object.
        """
        self.node.append_child(child)
        return self

    def with_styles(self, styles: dict) -> "Builder":
        """
        Adds styles to the tag.

        Args:
            styles (dict): Dictionary of styles.

        Returns:
            Builder: The Builder object.
        """
        style_str = ";".join([f"{k}:{v}" for k, v in styles.items()])
        self.node.attributes.append(Attribute("style", style_str))
        return self

    def with_classes(self, *class_names: str) -> "Builder":
        """
        Adds multiple class names to the element.

        Args:
            *class_names (str): Variable number of class names.

        Returns:
            Builder: The Builder object.
        """
        for class_name in class_names:
            self.with_class(class_name)
        return self

    def with_class(self, class_name: str) -> "Builder":
        """
        Adds a single class name to the element.

        Args:
            class_name (str): The class name to be added.

        Returns:
            Builder: The Builder object.
        """
        for i in self.node.attributes:
            if i.key == "class":
                if class_name not in i.value:
                    i.value = i.value + " " + class_name
                    return self
        self.node.attributes.append(Attribute("class", class_name))

        return self

    def with_class_if(self, class_name: str, condition: bool) -> "Builder":
        """
        Adds a class name to the element if the condition is True.
        If the condition is False, the class is not added.

        args:
            class_name (str): The class name to be added.
            condition (bool): The condition for adding the class.
        """
        self.with_class(class_name) if condition else None
        return self

    def with_attribute_if(self, key: str, value: any, condition: bool) -> "Builder":
        """
            adds attribute if condition is true
            args:
            key (str): The key of the attribute.
            value: The value of the attribute.
            condition (bool): The condition for adding the attribute.
        """
        self.with_attribute(key, value) if condition else None
        return self

    def with_child_if(self, child: Node, condition: bool) -> "Builder":
        """
            adds child if condition is true
            args:
            child (Node): The child node to be added.
            condition (bool): The condition for adding the child.
        """
        self.with_child(child) if condition else None
        return self

    def with_text(self, text: str):
        """
            add text node
        """
        self.with_child(Node(text=text))
        return self

    def build(self) -> Node:
        """
        Builds and returns the node.

        Returns:
            Node: The built node.
        """
        return self.node

__init__(name='div')

Initializes a Builder object with the given tag name.

Parameters:

Name Type Description Default
name str

The name of the tag. Defaults to "div".

 'div'
Source code in zenaura/client/tags/builder.py 
15
16
17
18
19
20
21
22
def __init__(self, name: str = "div") -> None:
    """
    Initializes a Builder object with the given tag name.

    Args:
        name (str, optional): The name of the tag. Defaults to "div".
    """
    self.node = Node(name)

build()

Builds and returns the node.

Returns:

Name Type Description
Node Node

The built node.
Source code in zenaura/client/tags/builder.py 
166
167
168
169
170
171
172
173
def build(self) -> Node:
    """
    Builds and returns the node.

    Returns:
        Node: The built node.
    """
    return self.node

with_attribute(key, value)

Adds an attribute to the tag.

Parameters:

Name Type Description Default
key str

The key of the attribute.

 required
value any

The value of the attribute.

 required

Returns:

Name Type Description
Builder Builder

The Builder object.
Source code in zenaura/client/tags/builder.py 
52
53
54
55
56
57
58
59
60
61
62
63
64
def with_attribute(self, key: str, value: any) -> "Builder":
    """
    Adds an attribute to the tag.

    Args:
        key (str): The key of the attribute.
        value: The value of the attribute.

    Returns:
        Builder: The Builder object.
    """
    self.node.attributes.append(Attribute(key, value))
    return self

with_attribute_if(key, value, condition)

adds attribute if condition is true args: key (str): The key of the attribute. value: The value of the attribute. condition (bool): The condition for adding the attribute.

Source code in zenaura/client/tags/builder.py 
138
139
140
141
142
143
144
145
146
147
def with_attribute_if(self, key: str, value: any, condition: bool) -> "Builder":
    """
        adds attribute if condition is true
        args:
        key (str): The key of the attribute.
        value: The value of the attribute.
        condition (bool): The condition for adding the attribute.
    """
    self.with_attribute(key, value) if condition else None
    return self

with_attributes(**kwargs)

Adds attributes to the tag.

Parameters:

Name Type Description Default
**kwargs

Key-value pairs of attributes.

 {}

Returns:

Name Type Description
Builder Builder

The Builder object.
Source code in zenaura/client/tags/builder.py 
24
25
26
27
28
29
30
31
32
33
34
35
36
def with_attributes(self, **kwargs) -> "Builder":
    """
    Adds attributes to the tag.

    Args:
        **kwargs: Key-value pairs of attributes.

    Returns:
        Builder: The Builder object.
    """
    for key, value in kwargs.items():
        self.with_attribute(key, value)
    return self

with_child(child)

Adds a child node to the tag.

Parameters:

Name Type Description Default
child Node

The child node to be added.

 required

Returns:

Name Type Description
Builder Builder

The Builder object.
Source code in zenaura/client/tags/builder.py 
66
67
68
69
70
71
72
73
74
75
76
77
def with_child(self, child: Node) -> "Builder":
    """
    Adds a child node to the tag.

    Args:
        child (Node): The child node to be added.

    Returns:
        Builder: The Builder object.
    """
    self.node.append_child(child)
    return self

with_child_if(child, condition)

adds child if condition is true args: child (Node): The child node to be added. condition (bool): The condition for adding the child.

Source code in zenaura/client/tags/builder.py 
149
150
151
152
153
154
155
156
157
def with_child_if(self, child: Node, condition: bool) -> "Builder":
    """
        adds child if condition is true
        args:
        child (Node): The child node to be added.
        condition (bool): The condition for adding the child.
    """
    self.with_child(child) if condition else None
    return self

with_children(*children)

Adds child nodes to the tag.

Parameters:

Name Type Description Default
*children

List of child nodes.

 ()

Returns:

Name Type Description
Builder Builder

The Builder object.
Source code in zenaura/client/tags/builder.py 
38
39
40
41
42
43
44
45
46
47
48
49
50
def with_children(self, *children) -> "Builder":
    """
    Adds child nodes to the tag.

    Args:
        *children: List of child nodes.

    Returns:
        Builder: The Builder object.
    """
    for child in children:
        self.with_child(child)
    return self

with_class(class_name)

Adds a single class name to the element.

Parameters:

Name Type Description Default
class_name str

The class name to be added.

 required

Returns:

Name Type Description
Builder Builder

The Builder object.
Source code in zenaura/client/tags/builder.py 
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
def with_class(self, class_name: str) -> "Builder":
    """
    Adds a single class name to the element.

    Args:
        class_name (str): The class name to be added.

    Returns:
        Builder: The Builder object.
    """
    for i in self.node.attributes:
        if i.key == "class":
            if class_name not in i.value:
                i.value = i.value + " " + class_name
                return self
    self.node.attributes.append(Attribute("class", class_name))

    return self

with_class_if(class_name, condition)

Adds a class name to the element if the condition is True. If the condition is False, the class is not added.

Parameters:

Name Type Description Default
class_name str

The class name to be added.

 required
condition bool

The condition for adding the class.

 required
Source code in zenaura/client/tags/builder.py 
126
127
128
129
130
131
132
133
134
135
136
def with_class_if(self, class_name: str, condition: bool) -> "Builder":
    """
    Adds a class name to the element if the condition is True.
    If the condition is False, the class is not added.

    args:
        class_name (str): The class name to be added.
        condition (bool): The condition for adding the class.
    """
    self.with_class(class_name) if condition else None
    return self

with_classes(*class_names)

Adds multiple class names to the element.

Parameters:

Name Type Description Default
*class_names str

Variable number of class names.

 ()

Returns:

Name Type Description
Builder Builder

The Builder object.
Source code in zenaura/client/tags/builder.py 
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
def with_classes(self, *class_names: str) -> "Builder":
    """
    Adds multiple class names to the element.

    Args:
        *class_names (str): Variable number of class names.

    Returns:
        Builder: The Builder object.
    """
    for class_name in class_names:
        self.with_class(class_name)
    return self

with_styles(styles)

Adds styles to the tag.

Parameters:

Name Type Description Default
styles dict

Dictionary of styles.

 required

Returns:

Name Type Description
Builder Builder

The Builder object.
Source code in zenaura/client/tags/builder.py 
79
80
81
82
83
84
85
86
87
88
89
90
91
def with_styles(self, styles: dict) -> "Builder":
    """
    Adds styles to the tag.

    Args:
        styles (dict): Dictionary of styles.

    Returns:
        Builder: The Builder object.
    """
    style_str = ";".join([f"{k}:{v}" for k, v in styles.items()])
    self.node.attributes.append(Attribute("style", style_str))
    return self

with_text(text)

add text node

Source code in zenaura/client/tags/builder.py 
159
160
161
162
163
164
def with_text(self, text: str):
    """
        add text node
    """
    self.with_child(Node(text=text))
    return self