PyPI - webwidgets - Versions diffs - 0.2.0__tar.gz → 1.0.0__tar.gz - Mend

webwidgets 0.2.0tar.gz → 1.0.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

webwidgets-1.0.0/.gitignore ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ __pycache__
2	+ ignore

webwidgets-1.0.0/PKG-INFO ADDED Viewed

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: webwidgets
+Version: 1.0.0
+Summary: A Python package for designing web UIs.
+Project-URL: Source code, https://github.com/mlaasri/WebWidgets
+Author: mlaasri
+License-File: LICENSE
+Keywords: design,webui
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+# WebWidgets
+![CI Status](https://img.shields.io/github/actions/workflow/status/mlaasri/WebWidgets/ci-full.yml?branch=main)
+A Python package for creating web UIs
+## Installation
+You can install **WebWidgets** with `pip`. To install the latest stable version, run:
+```bash
+pip install webwidgets
+```
+## Usage
+**WebWidgets** allows you to create custom widgets and build websites with them. For example:
+```python
+import webwidgets as ww
+from webwidgets.compilation.html import HTMLNode, RawText
+# A <div> element
+class Div(HTMLNode):
+    pass
+# A simple text widget
+class Text(ww.Widget):
+    def build(self):
+        return Div([RawText("Hello, World!")])
+# A website with one page containing a Text widget
+page = ww.Page([Text()])
+website = ww.Website([page])
+# Compile the website into HTML code
+compiled = website.compile()
+print(compiled.html_content[0])
+```
+Prints the following result:
+```console
+<!DOCTYPE html>
+<html>
+    <head></head>
+    <body>
+        <div>
+            Hello, World!
+        </div>
+    </body>
+</html>
+```

webwidgets-1.0.0/README.md ADDED Viewed

@@ -0,0 +1,53 @@
+# WebWidgets
+![CI Status](https://img.shields.io/github/actions/workflow/status/mlaasri/WebWidgets/ci-full.yml?branch=main)
+A Python package for creating web UIs
+## Installation
+You can install **WebWidgets** with `pip`. To install the latest stable version, run:
+```bash
+pip install webwidgets
+```
+## Usage
+**WebWidgets** allows you to create custom widgets and build websites with them. For example:
+```python
+import webwidgets as ww
+from webwidgets.compilation.html import HTMLNode, RawText
+# A <div> element
+class Div(HTMLNode):
+    pass
+# A simple text widget
+class Text(ww.Widget):
+    def build(self):
+        return Div([RawText("Hello, World!")])
+# A website with one page containing a Text widget
+page = ww.Page([Text()])
+website = ww.Website([page])
+# Compile the website into HTML code
+compiled = website.compile()
+print(compiled.html_content[0])
+```
+Prints the following result:
+```console
+<!DOCTYPE html>
+<html>
+    <head></head>
+    <body>
+        <div>
+            Hello, World!
+        </div>
+    </body>
+</html>
+```

{webwidgets-0.2.0 → webwidgets-1.0.0}/tests/compilation/test_css.py RENAMED Viewed

@@ -11,12 +11,38 @@
 # =======================================================================
 import pytest
+from typing import Any, Dict, List
 from webwidgets.compilation.html.html_node import HTMLNode
 from webwidgets.compilation.html.html_tags import TextNode
-from webwidgets.compilation.css.css import compile_css, CompiledCSS, apply_css
+from webwidgets.compilation.css.css import compile_css, CSSRule, CompiledCSS, \
+    apply_css, default_rule_namer
 class TestCompileCSS:
+    @staticmethod
+    def _serialize_rules(rules: List[CSSRule]) -> List[Dict[str, Any]]:
+        """Utility function to convert a list of :py:class:`CSSRule` objects
+        into a dictionary that can be used in testing.
+        :param rules: List of :py:class:`CSSRule` objects.
+        :type rules: List[CSSRule]
+        :return: List of the member variables of each :py:class:`CSSRule`.
+        :rtype: Dict[int, Any]
+        """
+        return [vars(rule) for rule in rules]
+    @staticmethod
+    def _serialize_mapping(mapping: Dict[int, List[CSSRule]]) -> Dict[int, List[str]]:
+        """Utility function to convert a :py:attr:`CompiledCSS.mapping` object
+        into a dictionary that can be used in testing.
+        :param mapping: :py:attr:`CompiledCSS.mapping` object.
+        :type mapping: Dict[int, List[CSSRule]]
+        :return: Dictionary mapping each node ID to the name of the rules that
+            achieve the same style.
+        """
+        return {i: [r.name for r in rules] for i, rules in mapping.items()}
     def test_argument_type(self):
         """Compares compilation when given a node object versus a list of
         nodes.
@@ -30,10 +56,10 @@ class TestCompileCSS:
         )
         # Define expected compilation results
-        expected_rules = {
-            'r0': {'a': '5'},
-            'r1': {'b': '4'}
-        }
+        expected_rules = [
+            {"name": "r0", "declarations": {"a": "5"}},
+            {"name": "r1", "declarations": {"b": "4"}}
+        ]
         expected_mapping = {
             id(tree): ['r0', 'r1'],
             id(tree.children[0]): ['r0']
@@ -45,8 +71,10 @@ class TestCompileCSS:
         # Check results of compilation
         assert compiled_css.trees == [tree]
         assert [id(t) for t in compiled_css.trees] == [id(tree)]
-        assert compiled_css.rules == expected_rules
-        assert compiled_css.mapping == expected_mapping
+        assert TestCompileCSS._serialize_rules(
+            compiled_css.rules) == expected_rules
+        assert TestCompileCSS._serialize_mapping(
+            compiled_css.mapping) == expected_mapping
         # Compile tree as list of one node
         compiled_css2 = compile_css([tree])
@@ -54,8 +82,10 @@ class TestCompileCSS:
         # Check results of compilation again (should be unchanged)
         assert compiled_css2.trees == [tree]
         assert [id(t) for t in compiled_css2.trees] == [id(tree)]
-        assert compiled_css2.rules == expected_rules
-        assert compiled_css2.mapping == expected_mapping
+        assert TestCompileCSS._serialize_rules(
+            compiled_css2.rules) == expected_rules
+        assert TestCompileCSS._serialize_mapping(
+            compiled_css2.mapping) == expected_mapping
     def test_basic_compilation(self):
         # Create some HTML nodes with different styles
@@ -72,17 +102,19 @@ class TestCompileCSS:
             id(node1), id(node2), id(node3)]
         # Check that the rules are correctly generated
-        expected_rules = {
-            'r0': {'color': 'blue'},
-            'r1': {'margin': '0'},
-            'r2': {'padding': '0'}
-        }
-        assert compiled_css.rules == expected_rules
+        expected_rules = [
+            {"name": "r0", "declarations": {"color": "blue"}},
+            {"name": "r1", "declarations": {"margin": "0"}},
+            {"name": "r2", "declarations": {"padding": "0"}}
+        ]
+        assert TestCompileCSS._serialize_rules(
+            compiled_css.rules) == expected_rules
         # Check that the mapping is correctly generated
         expected_mapping = {id(node1): ['r1', 'r2'], id(
             node2): ['r0', 'r1'], id(node3): ['r1', 'r2']}
-        assert compiled_css.mapping == expected_mapping
+        assert TestCompileCSS._serialize_mapping(
+            compiled_css.mapping) == expected_mapping
     def test_nested_compilation_one_tree(self):
         # Create some nested HTML nodes
@@ -104,13 +136,14 @@ class TestCompileCSS:
         assert [id(t) for t in compiled_css.trees] == [id(tree)]
         # Check that the rules are correctly generated
-        expected_rules = {
-            'r0': {'color': 'blue'},
-            'r1': {'margin': '0'},
-            'r2': {'margin': '5'},
-            'r3': {'padding': '0'}
-        }
-        assert compiled_css.rules == expected_rules
+        expected_rules = [
+            {"name": "r0", "declarations": {"color": "blue"}},
+            {"name": "r1", "declarations": {"margin": "0"}},
+            {"name": "r2", "declarations": {"margin": "5"}},
+            {"name": "r3", "declarations": {"padding": "0"}}
+        ]
+        assert TestCompileCSS._serialize_rules(
+            compiled_css.rules) == expected_rules
         # Check that the mapping is correctly generated
         expected_mapping = {
@@ -120,7 +153,8 @@ class TestCompileCSS:
             id(tree.children[0].children[0]): [],
             id(tree.children[1].children[0]): []
         }
-        assert compiled_css.mapping == expected_mapping
+        assert TestCompileCSS._serialize_mapping(
+            compiled_css.mapping) == expected_mapping
     def test_nested_compilation_two_trees(self):
         # Create 2 trees
@@ -146,13 +180,14 @@ class TestCompileCSS:
             id(tree1), id(tree2)]
         # Check that the rules are correctly generated
-        expected_rules = {
-            'r0': {'color': 'red'},
-            'r1': {'margin': '10'},
-            'r2': {'margin': '5'},
-            'r3': {'padding': '0'}
-        }
-        assert compiled_css.rules == expected_rules
+        expected_rules = [
+            {"name": "r0", "declarations": {"color": "red"}},
+            {"name": "r1", "declarations": {"margin": "10"}},
+            {"name": "r2", "declarations": {"margin": "5"}},
+            {"name": "r3", "declarations": {"padding": "0"}}
+        ]
+        assert TestCompileCSS._serialize_rules(
+            compiled_css.rules) == expected_rules
         # Check that the mapping is correctly generated
         expected_mapping = {
@@ -161,7 +196,8 @@ class TestCompileCSS:
             id(tree2): ['r2', 'r3'],
             id(tree2.children[0]): ['r1']
         }
-        assert compiled_css.mapping == expected_mapping
+        assert TestCompileCSS._serialize_mapping(
+            compiled_css.mapping) == expected_mapping
     def test_rules_numbered_in_order(self):
         """Test that rules are numbered in lexicographical order"""
@@ -174,14 +210,15 @@ class TestCompileCSS:
             ]
         )
         compiled_css = compile_css(tree)
-        expected_rules = {
-            'r0': {'a': '10'},
-            'r1': {'a': '5'},
-            'r2': {'b': '10'},
-            'r3': {'b': '4'},
-            'r4': {'c': '5'}
-        }
-        assert compiled_css.rules == expected_rules
+        expected_rules = [
+            {"name": "r0", "declarations": {"a": "10"}},
+            {"name": "r1", "declarations": {"a": "5"}},
+            {"name": "r2", "declarations": {"b": "10"}},
+            {"name": "r3", "declarations": {"b": "4"}},
+            {"name": "r4", "declarations": {"c": "5"}},
+        ]
+        assert TestCompileCSS._serialize_rules(
+            compiled_css.rules) == expected_rules
     def test_duplicate_node(self):
         """Test that adding the same node twice does not impact compilation"""
@@ -193,11 +230,11 @@ class TestCompileCSS:
                 HTMLNode(style={"b": "10"}),
             ]
         )
-        expected_rules = {
-            'r0': {'a': '5'},
-            'r1': {'b': '10'},
-            'r2': {'b': '4'}
-        }
+        expected_rules = [
+            {"name": "r0", "declarations": {"a": "5"}},
+            {"name": "r1", "declarations": {"b": "10"}},
+            {"name": "r2", "declarations": {"b": "4"}}
+        ]
         expected_mapping = {
             id(tree): ['r0', 'r2'],
             id(tree.children[0]): ['r0'],
@@ -206,8 +243,10 @@ class TestCompileCSS:
         compiled_css = compile_css([tree])
         assert compiled_css.trees == [tree]
         assert [id(t) for t in compiled_css.trees] == [id(tree)]
-        assert compiled_css.rules == expected_rules
-        assert compiled_css.mapping == expected_mapping
+        assert TestCompileCSS._serialize_rules(
+            compiled_css.rules) == expected_rules
+        assert TestCompileCSS._serialize_mapping(
+            compiled_css.mapping) == expected_mapping
         # Compiling the tree and one of its children, which should already be
         # included recursively from the tree itself and should not affect the
@@ -216,25 +255,41 @@ class TestCompileCSS:
         assert compiled_css2.trees == [tree, tree.children[0]]
         assert [id(t) for t in compiled_css2.trees] == [
             id(tree), id(tree.children[0])]
-        assert compiled_css2.rules == expected_rules
-        assert compiled_css2.mapping == expected_mapping
+        assert TestCompileCSS._serialize_rules(
+            compiled_css2.rules) == expected_rules
+        assert TestCompileCSS._serialize_mapping(
+            compiled_css2.mapping) == expected_mapping
+    @pytest.mark.parametrize("rule_namer, names", [
+        (lambda _, i: f"rule{i}", ["rule0", "rule1", "rule2"]),
+        (lambda _, i: f"rule-{i + 1}", ["rule-1", "rule-2", "rule-3"]),
+        (lambda r, i: f"{list(r[i].declarations.items())[0][0]}{i}", [
+            "az0", "bz1", "bz2"]),
+        (lambda r, i: f"{list(r[i].declarations.items())[0][0][0]}{i}", [
+            "a0", "b1", "b2"]),
+        (lambda r, i: f"r{list(r[i].declarations.items())[0][1]}-{i}", [
+            "r10-1", "r4-2", "r5-0"]),
+    ])
+    def test_custom_rule_names(self, rule_namer, names):
+        tree = HTMLNode(
+            style={"az": "5", "bz": "4"},
+            children=[
+                HTMLNode(style={"az": "5"}),
+                HTMLNode(style={"bz": "10"}),
+            ]
+        )
+        compiled_css = compile_css(tree, rule_namer=rule_namer)
+        assert [r.name for r in compiled_css.rules] == names
 class TestCompiledCSS:
     def test_export_custom_compiled_css(self):
-        rules = {
-            "r0": {
-                "margin": "0",
-                "padding": "0"
-            },
-            "r1": {
-                "color": "blue"
-            },
-            "r2": {
-                "background-color": "white",
-                "font-size": "16px"
-            }
-        }
+        rules = [
+            CSSRule(name="r0", declarations={"margin": "0", "padding": "0"}),
+            CSSRule(name="r1", declarations={"color": "blue"}),
+            CSSRule(name="r2", declarations={
+                    "background-color": "white", "font-size": "16px"})
+        ]
         compiled_css = CompiledCSS(trees=None,
                                    rules=rules,
                                    mapping=None)
@@ -364,12 +419,12 @@ class TestApplyCSS:
         # Compiling and applying CSS to the tree
         compiled_css = compile_css(tree)
-        assert compiled_css.rules == {
-            "r0": {"color": "blue"},
-            "r1": {"color": "green"},
-            "r2": {"margin": "0"},
-            "r3": {"padding": "0"}
-        }
+        assert TestCompileCSS._serialize_rules(compiled_css.rules) == [
+            {"name": "r0", "declarations": {"color": "blue"}},
+            {"name": "r1", "declarations": {"color": "green"}},
+            {"name": "r2", "declarations": {"margin": "0"}},
+            {"name": "r3", "declarations": {"padding": "0"}}
+        ]
         apply_css(compiled_css, tree)
         # Checking the tree's new classes
@@ -398,7 +453,7 @@ class TestApplyCSS:
         )
         html_before = tree.to_html()
         compiled_css = compile_css(tree)
-        assert compiled_css.rules == {}
+        assert compiled_css.rules == []
         apply_css(compiled_css, tree)
         html_after = tree.to_html()
@@ -475,3 +530,23 @@ class TestApplyCSS:
         apply_css(compiled_css, tree)
         assert "class" not in tree.attributes
         assert tree.to_html() == '<htmlnode></htmlnode>'
+class TestDefaultRuleNamer:
+    def test_default_rule_namer(self):
+        rules = [CSSRule(None, {"color": "red"}),
+                 CSSRule(None, {"margin": "0"})]
+        for i, rule in enumerate(rules):
+            rule.name = default_rule_namer(rules=rules, index=i)
+        assert rules[0].name == "r0"
+        assert rules[1].name == "r1"
+    def test_default_rule_namer_override(self):
+        rules = [CSSRule("first", {"color": "red"}),
+                 CSSRule("second", {"margin": "0"})]
+        assert rules[0].name == "first"
+        assert rules[1].name == "second"
+        for i, rule in enumerate(rules):
+            rule.name = default_rule_namer(rules=rules, index=i)
+        assert rules[0].name == "r0"
+        assert rules[1].name == "r1"

{webwidgets-0.2.0 → webwidgets-1.0.0}/tests/compilation/test_html_node.py RENAMED Viewed

@@ -12,7 +12,7 @@
 import pytest
 from webwidgets.compilation.html.html_node import HTMLNode, no_start_tag, \
-    no_end_tag, one_line, RawText
+    no_end_tag, one_line, RawText, RootNode
 class TestHTMLNode:
@@ -63,9 +63,14 @@ class TestHTMLNode:
     def test_attributes(self):
         node = HTMLNode(attributes={'id': 'test-id', 'class': 'test-class'})
-        assert node.start_tag == '<htmlnode id="test-id" class="test-class">'
+        assert node.start_tag == '<htmlnode class="test-class" id="test-id">'
         assert node.end_tag == '</htmlnode>'
-        assert node.to_html() == '<htmlnode id="test-id" class="test-class"></htmlnode>'
+        assert node.to_html() == '<htmlnode class="test-class" id="test-id"></htmlnode>'
+    def test_attributes_order(self):
+        node = HTMLNode(attributes={'d': '0', 'a': '1', 'c': '2', 'b': '3'})
+        assert node._render_attributes() == 'a="1" b="3" c="2" d="0"'
+        assert node.to_html() == '<htmlnode a="1" b="3" c="2" d="0"></htmlnode>'
     def test_no_start_tag(self):
         node = TestHTMLNode.NoStartNode()
@@ -230,7 +235,7 @@ class TestHTMLNode:
         assert node.to_html() == expected_html
     @pytest.mark.parametrize("indent_level", [0, 1, 2])
-    @pytest.mark.parametrize("indent_size", [3, 4, 8])
+    @pytest.mark.parametrize("indent_size", [2, 3, 4, 8])
     def test_indentation(self, indent_level: int, indent_size: int):
         """Test the to_html method with different indentation parameters."""
@@ -270,6 +275,28 @@ class TestHTMLNode:
             indent_size=indent_size, indent_level=indent_level)
         assert actual_html == expected_html
+    @pytest.mark.parametrize("indent_level", [-3, -2, -1])
+    def test_negative_indent_level(self, indent_level: int):
+        node = HTMLNode(children=[
+            RawText('child1'),
+            RawText('child2'),
+            HTMLNode(children=[
+                RawText('grandchild1'),
+                RawText('grandchild2')
+            ])
+        ])
+        expected_html = "\n".join([
+            "<htmlnode>",
+            "child1",
+            "child2",
+            "<htmlnode>",
+            f"{'    ' if indent_level == -1 else ''}grandchild1",
+            f"{'    ' if indent_level == -1 else ''}grandchild2",
+            "</htmlnode>",
+            "</htmlnode>"
+        ])
+        assert node.to_html(indent_level=indent_level) == expected_html
     def test_collapse_empty(self):
         node = HTMLNode(children=[
             TestHTMLNode.CustomNode(),
@@ -441,3 +468,16 @@ class TestHTMLNode:
         copied_node.children.append(child)
         assert len(node.children) == 1
         assert id(node.children[0]) == id(child)
+    def test_empty_root_node(self):
+        node = RootNode()
+        assert node.to_html() == ""
+    @pytest.mark.parametrize("n", [1, 2, 3])
+    def test_root_node_with_children(self, n):
+        node = RootNode(
+            children=[HTMLNode()] * n
+        )
+        expected_html = "\n".join(["<htmlnode></htmlnode>"] * n)
+        print(expected_html)
+        assert node.to_html() == expected_html

{webwidgets-0.2.0 → webwidgets-1.0.0}/tests/compilation/test_html_tags.py RENAMED Viewed

@@ -21,7 +21,21 @@ class TestHTMLTags:
     def test_text_node_with_attributes(self):
         text_node = TextNode("Hello, World!",
                              attributes={"class": "my-class", "id": "my-id"})
-        assert text_node.to_html() in [
-            '<textnode class="my-class" id="my-id">Hello, World!</textnode>',
-            '<textnode id="my-id" class="my-class">Hello, World!</textnode>',
-        ]
+        assert text_node.to_html() == \
+            '<textnode class="my-class" id="my-id">Hello, World!</textnode>'
+    def test_body(self):
+        body = Body()
+        assert body.to_html() == "<body></body>"
+    def test_doctype(self):
+        doctype = Doctype()
+        assert doctype.to_html() == "<!DOCTYPE html>"
+    def test_head(self):
+        head = Head()
+        assert head.to_html() == "<head></head>"
+    def test_html(self):
+        html = Html()
+        assert html.to_html() == "<html></html>"

webwidgets-1.0.0/tests/utility/test_indentation.py ADDED Viewed

@@ -0,0 +1,29 @@
+# =======================================================================
+#
+#  This file is part of WebWidgets, a Python package for designing web
+#  UIs.
+#
+#  You should have received a copy of the MIT License along with
+#  WebWidgets. If not, see <https://opensource.org/license/mit>.
+#
+#  Copyright(C) 2025, mlaasri
+#
+# =======================================================================
+import pytest
+from webwidgets.utility.indentation import get_indentation
+class TestIndentation:
+    @pytest.mark.parametrize("indent_level", [0, 1, 2])
+    @pytest.mark.parametrize("indent_size", [3, 4, 8])
+    def test_get_indentation(self, indent_level: int, indent_size: int):
+        """Tests get_indentation with different indentation levels and sizes."""
+        expected_indentation = ' ' * indent_size * indent_level
+        assert get_indentation(
+            indent_level, indent_size) == expected_indentation
+    @pytest.mark.parametrize("indent_level", [-2, -1, 0])
+    @pytest.mark.parametrize("indent_size", [3, 4, 8])
+    def test_get_indentation_for_negative_levels(self, indent_level, indent_size):
+        assert get_indentation(indent_level, indent_size) == ''

webwidgets 0.2.0__tar.gz → 1.0.0__tar.gz

webwidgets 0.2.0tar.gz → 1.0.0tar.gz