python-fragments 0.28__tar.gz → 0.31__tar.gz

python_fragments-0.31/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 The Running Algorithm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_fragments-0.31/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: python-fragments
+Version: 0.31
+Summary: Modern HTML template rendering in Python
+Author-email: The Running Algorithm <services@therunningalgorithm.info>
+License: MIT License
+        
+        Copyright (c) 2026 The Running Algorithm
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: lsp
+Requires-Dist: basedpyright>=1.39.0; extra == "lsp"
+Requires-Dist: lsprotocol>=2025.0.0; extra == "lsp"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.4.1; extra == "dev"
+Dynamic: license-file
+
+# Python Fragments
+
+> **This package is in early development and not yet stable. The API may change without notice between releases.**
+
+Modern HTML template rendering in Python — no build step, no template files, and native HTML awareness out of the box.
+
+```python
+from fragments import loader  # isort: skip
+
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse
+from components import Layout, PostCard
+
+app = FastAPI()
+
+POSTS = [...]
+
+@app.get("/", response_class=HTMLResponse)
+async def index() -> str:
+    published = [p for p in POSTS if p.published]
+    return <>
+        <Layout title="My Blog">
+            <h1>Latest Posts</h1>
+            <PostCard for={{ post in published }} post={{ post }} />
+        </Layout>
+    </>
+```
+
+## IDE Support
+
+Type checking, completions, hover docs, go-to-definition, rename, and semantic highlighting — all working inside fragment syntax.
+
+![VS Code completions demo](docs/assets/vscode.gif)
+
+## Installation
+
+```bash
+pip install python-fragments
+```
+
+Register the loader at your application's entry point, before importing any modules that contain fragments:
+
+```python
+from fragments import loader  # isort: skip
+```
+
+Any `.py` file containing `<>` is transpiled automatically. Nothing else to configure.
+
+## Feedback and feature requests
+
+Bug reports and feature requests are welcome via [GitHub Issues](https://github.com/TheRunningAlgorithm2/python-fragments/issues). The project is not currently accepting code contributions.

{python_fragments-0.28 → python_fragments-0.31}/README.md

@@ -2,7 +2,7 @@
 
 > **This package is in early development and not yet stable. The API may change without notice between releases.**
 
-Production-ready, modern HTML template rendering in Python — no build step, no template files, and native HTML awareness out of the box.
+Modern HTML template rendering in Python — no build step, no template files, and native HTML awareness out of the box.
 
 ```python
 from fragments import loader  # isort: skip
@@ -26,6 +26,12 @@ async def index() -> str:
     </>
 ```
 
+## IDE Support
+
+Type checking, completions, hover docs, go-to-definition, rename, and semantic highlighting — all working inside fragment syntax.
+
+![VS Code completions demo](docs/assets/vscode.gif)
+
 ## Installation
 
 ```bash
@@ -39,3 +45,7 @@ from fragments import loader  # isort: skip
 ```
 
 Any `.py` file containing `<>` is transpiled automatically. Nothing else to configure.
+
+## Feedback and feature requests
+
+Bug reports and feature requests are welcome via [GitHub Issues](https://github.com/TheRunningAlgorithm2/python-fragments/issues). The project is not currently accepting code contributions.

{python_fragments-0.28 → python_fragments-0.31}/fragments/ast_nodes.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass, field
 from typing import Sequence
 
-type ASTHTMLChild = ASTHTMLElement | ASTHTMLComment | ASTHTMLText | ASTInterpolation | ASTComponent | ASTControlNode
+type ASTHTMLChild = ASTHTMLElement | ASTHTMLComment | ASTHTMLText | ASTInterpolation | ASTComponent | ASTControlNode | ASTDoctype | ASTChildrenSlot
 
 
 @dataclass(slots=True)
@@ -15,7 +15,7 @@ class ASTModule:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __template__: str = "from fragments.html.elements import el, sequence, comment\n{}"
+    __template__: str = "from fragments.html.elements import el, _sequence, comment\n{}"
 
     def transpile(self, transpiled_start: int = 0) -> None:
         """Build transpiled outputs for the module."""
@@ -83,18 +83,15 @@ class ASTFragment:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __template__: str = """sequence([{}])"""
-
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
-        transpiled_start += 10
         for child in self.children:
             child.transpile(transpiled_start)
             transpiled_start = child.transpiled_end + 1
-        if len(self.children) > 0:
+        if self.children:
             transpiled_start -= 1
 
-        self.transpiled_content = self.__template__.format(",".join(child.transpiled_content for child in self.children))
+        self.transpiled_content = "+".join(child.transpiled_content for child in self.children) if self.children else '""'
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
@@ -126,26 +123,28 @@ class ASTHTMLElement:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __element_template__: str = """el("{}",[{}],oneline={},attributes={})"""
+    __element_template__: str = """el("{}",{},oneline={},attributes={})"""
 
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
-        transpiled_start = transpiled_start + len(self.name) + 7
+        transpiled_start = transpiled_start + len(self.name) + 6  # el("name",
         for child in self.children:
             child.transpile(transpiled_start)
             transpiled_start = child.transpiled_end + 1
-        if len(self.children) > 0:
+        if self.children:
             transpiled_start -= 1
-        children = ",".join(child.transpiled_content for child in self.children)
+        children_expr = "+".join(child.transpiled_content for child in self.children) if self.children else '""'
+        if not self.children:
+            transpiled_start += 2  # ""
         oneline_offset = len(str(self.one_line))
-        transpiled_start += 10 + oneline_offset + 12 + 1  # ],oneline= + oneline + ,attributes= + {
+        transpiled_start += 9 + oneline_offset + 12 + 1  # ,oneline= + oneline + ,attributes= + {
         for attribute in self.attributes.values():
             attribute.transpile(transpiled_start)
             transpiled_start = attribute.transpiled_end + 1
         transpiled_start -= 1
 
         attributes = "{" + ",".join(attribute.transpiled_content for attribute in self.attributes.values()) + "}"
-        self.transpiled_content = self.__element_template__.format(self.name, children, self.one_line, attributes)
+        self.transpiled_content = self.__element_template__.format(self.name, children_expr, self.one_line, attributes)
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
     def map_offset(self, offset: int) -> int | None:
@@ -184,18 +183,18 @@ class ASTControlNode[T: (ASTHTMLElement, ASTComponent)]:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __for_template__: str = "sequence([{} for {}])"
-    __if_template__: str = "{} if {} else ''"
+    __for_template__: str = "_sequence([{} for {}])"
+    __if_template__: str = "({} if {} else '')"
 
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
         if self.for_interpolation is not None:
-            self.child.transpile(transpiled_start + 10)  # sequence([
+            self.child.transpile(transpiled_start + 11)  # _sequence([
             self.for_interpolation.transpile(self.child.transpiled_end + 5)  # child +  for
             self.transpiled_content = self.__for_template__.format(self.child.transpiled_content, self.for_interpolation.transpiled_content)
         elif self.if_interpolation is not None:
-            self.child.transpile(transpiled_start)
-            self.if_interpolation.transpile(self.child.transpiled_end + 4)  # child +  if
+            self.child.transpile(transpiled_start + 1)  # ( before child
+            self.if_interpolation.transpile(self.child.transpiled_end + 4)  # " if "
             self.transpiled_content = self.__if_template__.format(self.child.transpiled_content, self.if_interpolation.transpiled_content)
         self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
 
@@ -250,25 +249,27 @@ class ASTComponent:
     transpiled_start: int = field(init=False)
     transpiled_end: int = field(init=False)
 
-    __template__: str = """{}([{}],{})"""
+    __template__: str = """{}({},{})"""
 
     def transpile(self, transpiled_start: int) -> None:
         self.transpiled_start = transpiled_start
         self.name.transpile(self.transpiled_start)
-        transpiled_start = self.name.transpiled_end + 2
+        transpiled_start = self.name.transpiled_end + 1  # (
         for child in self.children:
             child.transpile(transpiled_start)
-            transpiled_start = child.transpiled_end + 1
+            transpiled_start = child.transpiled_end + 1  # + between children
         if self.children:
             transpiled_start -= 1
-        children = ",".join(child.transpiled_content for child in self.children)
+        children = "+".join(child.transpiled_content for child in self.children) if self.children else '""'
+        if not self.children:
+            transpiled_start += 2  # ""
 
         if len(self.arguments) == 0:
             self.transpiled_content = self.__template__.format(self.name.transpiled_content, children, "")
             self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
             return
 
-        transpiled_start += 2
+        transpiled_start += 1  # , before arguments
         for attribute in self.arguments.values():
             attribute.transpile(transpiled_start)
             transpiled_start = attribute.transpiled_end + 1
@@ -392,6 +393,27 @@ class ASTComponentArgument:
         return None
 
 
+@dataclass(slots=True)
+class ASTDoctype:
+    source_start: int = field(compare=False)
+    source_end: int = field(compare=False)
+
+    transpiled_content: str = field(init=False)
+    transpiled_start: int = field(init=False)
+    transpiled_end: int = field(init=False)
+
+    def transpile(self, transpiled_start: int) -> None:
+        self.transpiled_start = transpiled_start
+        self.transpiled_content = '"<!DOCTYPE html>"'
+        self.transpiled_end = self.transpiled_start + len(self.transpiled_content)
+
+    def map_offset(self, offset: int) -> None:
+        return None
+
+    def unmap_offset(self, offset: int) -> None:
+        return None
+
+
 @dataclass(slots=True)
 class ASTHTMLComment:
     source_start: int = field(compare=False)
@@ -525,3 +547,24 @@ class ASTInterpolation:
             return self.source_start + specific_offset + 2 + self.leading_whitespace
 
         return None
+
+
+@dataclass(slots=True)
+class ASTChildrenSlot:
+    source_start: int = field(compare=False)
+    source_end: int = field(compare=False)
+
+    transpiled_content: str = field(init=False)
+    transpiled_start: int = field(init=False)
+    transpiled_end: int = field(init=False)
+
+    def transpile(self, transpiled_start: int) -> None:
+        self.transpiled_start = transpiled_start
+        self.transpiled_content = "children"
+        self.transpiled_end = transpiled_start + len("children")
+
+    def map_offset(self, offset: int) -> None:
+        return None
+
+    def unmap_offset(self, offset: int) -> None:
+        return None

{python_fragments-0.28 → python_fragments-0.31}/fragments/grammar.py

@@ -2,10 +2,12 @@ from re import Match
 import re
 
 from fragments.ast_nodes import (
+    ASTChildrenSlot,
     ASTComponent,
     ASTComponentArgument,
     ASTComponentName,
     ASTControlNode,
+    ASTDoctype,
     ASTFragment,
     ASTHTMLAttribute,
     ASTHTMLComment,
@@ -21,7 +23,6 @@ from fragments.source import Source
 HTML_IDENTIFIER = r"[a-zA-Z][a-zA-Z0-9_:.-]*"
 HTML_ATTRIBUTE_NAME = r"[a-zA-Z:-_][a-zA-Z0-9_:.-]*"
 HTML_TEXT = r"([\s\S]*?)(?=<|{{)"
-CHILDREN_META_COMPONENT = r"<[\S]*Children\.\.\.[\S]*/>"
 
 
 class ParsingError(Exception):
@@ -102,7 +103,9 @@ def expect_fragment(source: Source) -> tuple[Source, ASTFragment]:
 
     children: list[ASTHTMLChild] = []
     while not source.remaining().startswith("</>"):
-        source, _ = source.eat_whitespace()
+        source_after_whitespace, _ = source.eat_whitespace()
+        if source_after_whitespace.remaining().startswith("<"):
+            source = source_after_whitespace
         if source.remaining().startswith("</>"):
             break
         source, child = expect_child(source)
@@ -115,12 +118,26 @@ def expect_fragment(source: Source) -> tuple[Source, ASTFragment]:
     return source, ASTFragment(source_start, source_end, children)
 
 
+def expect_children_slot(source: Source) -> tuple[Source, ASTChildrenSlot]:
+    source_start = source.offset
+    source = expect_string(source, "<Children... />")
+    return source, ASTChildrenSlot(source_start, source.offset)
+
+
 def expect_child(source: Source) -> tuple[Source, ASTHTMLChild]:
     """Any HTML / functional block that might appear as part of the fragment."""
+    if source.remaining().startswith("<!DOCTYPE html>"):
+        source, doctype = expect_doctype(source)
+        return source, doctype
+
     if source.remaining().startswith("<!--"):
         source, html_comment = expect_html_comment(source)
         return source, html_comment
 
+    if source.remaining().startswith("<Children... />"):
+        source, children_slot = expect_children_slot(source)
+        return source, children_slot
+
     if source.start_matches(r"<[A-Z]"):
         source, component = expect_component(source)
         return source, component
@@ -192,6 +209,12 @@ def expect_component_name(source: Source) -> tuple[Source, ASTComponentName]:
     return source, ASTComponentName(source_start, source.offset, name)
 
 
+def expect_doctype(source: Source) -> tuple[Source, ASTDoctype]:
+    source_start = source.offset
+    source = expect_string(source, "<!DOCTYPE html>")
+    return source, ASTDoctype(source_start, source.offset)
+
+
 def expect_html_comment(source: Source) -> tuple[Source, ASTHTMLComment]:
     source_start = source.offset
     source = expect_string(source, "<!--")
@@ -270,7 +293,7 @@ def expect_children(source: Source) -> tuple[Source, list[ASTHTMLChild]]:
         source, child = expect_child(source)
         children.append(child)
         source_after_whitespace, _ = source.eat_whitespace()
-        if not source_after_whitespace.remaining().startswith("{{"):
+        if source_after_whitespace.remaining().startswith("<"):
             source = source_after_whitespace
     return source, children
 

{python_fragments-0.28 → python_fragments-0.31}/fragments/html/elements.py

@@ -1,11 +1,11 @@
 import json
 from typing import Any
-from fragments.types import Children
+from fragments.types import Children, Stringable
 import html
 
 
-def sequence(children: Children) -> str:
-    return "".join(str(child) for child in children)
+def _sequence(items: list[str | Stringable]) -> str:
+    return "".join(str(item) for item in items)
 
 
 def el(
@@ -26,9 +26,7 @@ def el(
     if oneline:
         return f"""<{tag_contents_string} />"""
 
-    children_string = sequence(children)
-
-    return f"""<{tag_contents_string}>{children_string}</{name}>"""
+    return f"""<{tag_contents_string}>{children}</{name}>"""
 
 
 def comment(content: str) -> str:

{python_fragments-0.28 → python_fragments-0.31}/fragments/types.py

@@ -5,5 +5,4 @@ class Stringable(Protocol):
     def __str__(self) -> str: ...
 
 
-type Child = str | Stringable
-type Children = list[Child]
+type Children = str

{python_fragments-0.28 → python_fragments-0.31}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-fragments"
-version = "0.28"
+version = "0.31"
 description = "Modern HTML template rendering in Python"
 authors = [{ name = "The Running Algorithm", email = "services@therunningalgorithm.info" }]
 readme = "README.md"
-license = { text = "Proprietary" }
+license = { file = "LICENSE" }
 requires-python = ">=3.12"
 dependencies = []
 

python_fragments-0.31/python_fragments.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: python-fragments
+Version: 0.31
+Summary: Modern HTML template rendering in Python
+Author-email: The Running Algorithm <services@therunningalgorithm.info>
+License: MIT License
+        
+        Copyright (c) 2026 The Running Algorithm
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: lsp
+Requires-Dist: basedpyright>=1.39.0; extra == "lsp"
+Requires-Dist: lsprotocol>=2025.0.0; extra == "lsp"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.4.1; extra == "dev"
+Dynamic: license-file
+
+# Python Fragments
+
+> **This package is in early development and not yet stable. The API may change without notice between releases.**
+
+Modern HTML template rendering in Python — no build step, no template files, and native HTML awareness out of the box.
+
+```python
+from fragments import loader  # isort: skip
+
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse
+from components import Layout, PostCard
+
+app = FastAPI()
+
+POSTS = [...]
+
+@app.get("/", response_class=HTMLResponse)
+async def index() -> str:
+    published = [p for p in POSTS if p.published]
+    return <>
+        <Layout title="My Blog">
+            <h1>Latest Posts</h1>
+            <PostCard for={{ post in published }} post={{ post }} />
+        </Layout>
+    </>
+```
+
+## IDE Support
+
+Type checking, completions, hover docs, go-to-definition, rename, and semantic highlighting — all working inside fragment syntax.
+
+![VS Code completions demo](docs/assets/vscode.gif)
+
+## Installation
+
+```bash
+pip install python-fragments
+```
+
+Register the loader at your application's entry point, before importing any modules that contain fragments:
+
+```python
+from fragments import loader  # isort: skip
+```
+
+Any `.py` file containing `<>` is transpiled automatically. Nothing else to configure.
+
+## Feedback and feature requests
+
+Bug reports and feature requests are welcome via [GitHub Issues](https://github.com/TheRunningAlgorithm2/python-fragments/issues). The project is not currently accepting code contributions.

{python_fragments-0.28 → python_fragments-0.31}/python_fragments.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.md
 pyproject.toml
 fragments/__init__.py
@@ -40,6 +41,7 @@ python_fragments.egg-info/dependency_links.txt
 python_fragments.egg-info/entry_points.txt
 python_fragments.egg-info/requires.txt
 python_fragments.egg-info/top_level.txt
+tests/test_end_to_end.py
 tests/test_grammar.py
 tests/test_html_elements.py
 tests/test_source_map.py

python_fragments-0.31/tests/test_end_to_end.py

@@ -0,0 +1,158 @@
+from fragments.grammar import expect_module
+from fragments.source import Source
+
+
+def render(source_str: str, **variables: object) -> str:
+    """Transpile a fragment source string, execute it, and return the result."""
+    source = Source.from_string(f"result = {source_str.strip()}")
+    _, module = expect_module(source)
+    module.transpile(0)
+    namespace: dict[str, object] = dict(variables)
+    exec(module.transpiled_content, namespace)
+    return str(namespace["result"])
+
+
+# ---------------------------------------------------------------------------
+# Basic elements
+# ---------------------------------------------------------------------------
+
+
+def test_single_element():
+    assert render("<><h1>Hello</h1></>") == "<h1>Hello</h1>"
+
+
+def test_multiple_siblings():
+    assert render("<><h1>Title</h1><p>Body</p></>") == "<h1>Title</h1><p>Body</p>"
+
+
+def test_nested_elements():
+    assert render("<><div><p>text</p></div></>") == "<div><p>text</p></div>"
+
+
+def test_self_closing_element():
+    assert render("<><br /></>") == "<br />"
+
+
+def test_empty_fragment():
+    assert render('<></>') == ""
+
+
+# ---------------------------------------------------------------------------
+# Interpolation
+# ---------------------------------------------------------------------------
+
+
+def test_interpolation():
+    assert render("<><p>{{ name }}</p></>", name="World") == "<p>World</p>"
+
+
+def test_multiple_interpolations():
+    assert render("<><p>{{ a }} and {{ b }}</p></>", a="foo", b="bar") == "<p>foo and bar</p>"
+
+
+def test_text_space_before_element():
+    assert render("<>Icon: <i></i></>") == "Icon: <i></i>"
+
+
+def test_text_space_after_element():
+    assert render("<><i></i> text</>") == "<i></i> text"
+
+
+def test_text_space_around_element():
+    assert render("<>before <i>em</i> after</>") == "before <i>em</i> after"
+
+
+# ---------------------------------------------------------------------------
+# Control flow — if
+# ---------------------------------------------------------------------------
+
+
+def test_if_true():
+    assert render("<><p if={{ cond }}>yes</p></>", cond=True) == "<p>yes</p>"
+
+
+def test_if_false():
+    assert render("<><p if={{ cond }}>yes</p></>", cond=False) == ""
+
+
+def test_if_true_with_sibling():
+    result = render("<><p if={{ cond }}>yes</p><p>always</p></>", cond=True)
+    assert result == "<p>yes</p><p>always</p>"
+
+
+def test_if_false_with_sibling():
+    result = render("<><p if={{ cond }}>yes</p><p>always</p></>", cond=False)
+    assert result == "<p>always</p>"
+
+
+def test_if_true_with_preceding_sibling():
+    result = render("<><p>always</p><p if={{ cond }}>maybe</p></>", cond=True)
+    assert result == "<p>always</p><p>maybe</p>"
+
+
+def test_if_false_with_preceding_sibling():
+    result = render("<><p>always</p><p if={{ cond }}>maybe</p></>", cond=False)
+    assert result == "<p>always</p>"
+
+
+def test_if_between_siblings():
+    result = render("<><p>before</p><p if={{ cond }}>maybe</p><p>after</p></>", cond=True)
+    assert result == "<p>before</p><p>maybe</p><p>after</p>"
+
+    result = render("<><p>before</p><p if={{ cond }}>maybe</p><p>after</p></>", cond=False)
+    assert result == "<p>before</p><p>after</p>"
+
+
+# ---------------------------------------------------------------------------
+# Control flow — for
+# ---------------------------------------------------------------------------
+
+
+def test_for_loop():
+    result = render("<><li for={{ item in items }}>{{ item }}</li></>", items=["a", "b", "c"])
+    assert result == "<li>a</li><li>b</li><li>c</li>"
+
+
+def test_for_loop_with_sibling():
+    result = render("<><h1>List</h1><li for={{ item in items }}>{{ item }}</li></>", items=["x", "y"])
+    assert result == "<h1>List</h1><li>x</li><li>y</li>"
+
+
+def test_for_loop_empty():
+    assert render("<><li for={{ item in items }}>{{ item }}</li></>", items=[]) == ""
+
+
+# ---------------------------------------------------------------------------
+# Components
+# ---------------------------------------------------------------------------
+
+
+def test_component_no_children():
+    def Badge(children: str, label: str) -> str:
+        return f"<span>{label}</span>"
+
+    result = render("<><Badge label=\"hi\" /></>", Badge=Badge)
+    assert result == "<span>hi</span>"
+
+
+def test_component_with_children():
+    from fragments.types import Children
+
+    def Wrapper(children: Children) -> str:
+        return f"<div>{children}</div>"
+
+    result = render("<><Wrapper><p>content</p></Wrapper></>", Wrapper=Wrapper)
+    assert result == "<div><p>content</p></div>"
+
+
+def test_component_children_pre_joined():
+    from fragments.types import Children
+
+    def Wrapper(children: Children) -> str:
+        return f"<div>{children}</div>"
+
+    result = render(
+        "<><Wrapper><p>one</p><p>two</p></Wrapper></>",
+        Wrapper=Wrapper,
+    )
+    assert result == "<div><p>one</p><p>two</p></div>"

{python_fragments-0.28 → python_fragments-0.31}/tests/test_grammar.py

@@ -2,10 +2,12 @@ import pytest
 
 from fragments import grammar
 from fragments.ast_nodes import (
+    ASTChildrenSlot,
     ASTComponent,
     ASTComponentArgument,
     ASTComponentName,
     ASTControlNode,
+    ASTDoctype,
     ASTFragment,
     ASTHTMLAttribute,
     ASTHTMLComment,
@@ -23,6 +25,47 @@ def _transpiled(fragment: ASTFragment) -> ASTFragment:
     return fragment
 
 
+# ---------------------------------------------------------------------------
+# Doctype
+# ---------------------------------------------------------------------------
+
+
+def test_doctype_standalone():
+    source = Source.from_string("<><!DOCTYPE html></>")
+    source, fragment = grammar.expect_fragment(source)
+    assert source.at_end()
+    assert _transpiled(fragment) == _transpiled(ASTFragment(-1, -1, [
+        ASTDoctype(-1, -1)
+    ]))
+
+
+def test_doctype_transpiles_to_literal_string():
+    source = Source.from_string("<><!DOCTYPE html></>")
+    _, fragment = grammar.expect_fragment(source)
+    fragment.transpile(0)
+    doctype = fragment.children[0]
+    assert isinstance(doctype, ASTDoctype)
+    assert doctype.transpiled_content == '"<!DOCTYPE html>"'
+
+
+def test_doctype_followed_by_element():
+    source = Source.from_string("<><!DOCTYPE html><html></html></>")
+    source, fragment = grammar.expect_fragment(source)
+    assert source.at_end()
+    assert _transpiled(fragment) == _transpiled(ASTFragment(-1, -1, [
+        ASTDoctype(-1, -1),
+        ASTHTMLElement(-1, -1, "html", {}, [], False),
+    ]))
+
+
+def test_doctype_not_confused_with_comment():
+    source = Source.from_string("<><!DOCTYPE html><!-- a note --></>")
+    source, fragment = grammar.expect_fragment(source)
+    assert source.at_end()
+    assert isinstance(fragment.children[0], ASTDoctype)
+    assert isinstance(fragment.children[1], ASTHTMLComment)
+
+
 # ---------------------------------------------------------------------------
 # Comments
 # ---------------------------------------------------------------------------
@@ -325,6 +368,53 @@ def test_lowercase_not_parsed_as_component():
     assert isinstance(fragment.children[0], ASTHTMLElement)
 
 
+# ---------------------------------------------------------------------------
+# Children slot
+# ---------------------------------------------------------------------------
+
+
+def test_children_slot_parses():
+    source = Source.from_string("<><Children... /></>")
+    source, fragment = grammar.expect_fragment(source)
+    assert source.at_end()
+    assert _transpiled(fragment) == _transpiled(ASTFragment(-1, -1, [
+        ASTChildrenSlot(-1, -1)
+    ]))
+
+
+def test_children_slot_transpiles_to_children():
+    source = Source.from_string("<><Children... /></>")
+    _, fragment = grammar.expect_fragment(source)
+    fragment.transpile(0)
+    slot = fragment.children[0]
+    assert isinstance(slot, ASTChildrenSlot)
+    assert slot.transpiled_content == "children"
+
+
+def test_children_slot_multiple_in_one_fragment():
+    source = Source.from_string("<><Children... /><Children... /></>")
+    source, fragment = grammar.expect_fragment(source)
+    assert source.at_end()
+    assert len(fragment.children) == 2
+    assert all(isinstance(child, ASTChildrenSlot) for child in fragment.children)
+
+
+def test_children_slot_not_confused_with_component():
+    source = Source.from_string("<><Children /></>")
+    source, fragment = grammar.expect_fragment(source)
+    assert source.at_end()
+    assert isinstance(fragment.children[0], ASTComponent)
+
+
+def test_children_slot_inside_element():
+    source = Source.from_string("<><div><Children... /></div></>")
+    source, fragment = grammar.expect_fragment(source)
+    assert source.at_end()
+    element = fragment.children[0]
+    assert isinstance(element, ASTHTMLElement)
+    assert isinstance(element.children[0], ASTChildrenSlot)
+
+
 # ---------------------------------------------------------------------------
 # HTML text
 # ---------------------------------------------------------------------------

{python_fragments-0.28 → python_fragments-0.31}/tests/test_html_elements.py

@@ -22,10 +22,10 @@ def test_className_string_passthrough():
 
 
 def test_el_className_list_attribute():
-    result = el("div", ["content"], False, {"className": ["foo", "bar"]})
+    result = el("div", "content", False, {"className": ["foo", "bar"]})
     assert result == '<div class="foo bar">content</div>'
 
 
 def test_el_className_empty_list():
-    result = el("div", [], True, {"className": []})
+    result = el("div", "", True, {"className": []})
     assert result == '<div class="" />'

{python_fragments-0.28 → python_fragments-0.31}/tests/test_source_map.py

@@ -1,7 +1,7 @@
 from fragments.lsp.file_state import FileState
 from lsprotocol import types
 
-IMPORT_PREFIX = "from fragments.html.elements import el, sequence, comment\n"
+IMPORT_PREFIX = "from fragments.html.elements import el, _sequence, comment\n"
 IMPORT_PREFIX_LEN = len(IMPORT_PREFIX)
 
 

python_fragments-0.28/PKG-INFO

@@ -1,55 +0,0 @@
-Metadata-Version: 2.4
-Name: python-fragments
-Version: 0.28
-Summary: Modern HTML template rendering in Python
-Author-email: The Running Algorithm <services@therunningalgorithm.info>
-License: Proprietary
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-Provides-Extra: lsp
-Requires-Dist: basedpyright>=1.39.0; extra == "lsp"
-Requires-Dist: lsprotocol>=2025.0.0; extra == "lsp"
-Provides-Extra: dev
-Requires-Dist: pytest>=8.4.1; extra == "dev"
-
-# Python Fragments
-
-> **This package is in early development and not yet stable. The API may change without notice between releases.**
-
-Production-ready, modern HTML template rendering in Python — no build step, no template files, and native HTML awareness out of the box.
-
-```python
-from fragments import loader  # isort: skip
-
-from fastapi import FastAPI
-from fastapi.responses import HTMLResponse
-from components import Layout, PostCard
-
-app = FastAPI()
-
-POSTS = [...]
-
-@app.get("/", response_class=HTMLResponse)
-async def index() -> str:
-    published = [p for p in POSTS if p.published]
-    return <>
-        <Layout title="My Blog">
-            <h1>Latest Posts</h1>
-            <PostCard for={{ post in published }} post={{ post }} />
-        </Layout>
-    </>
-```
-
-## Installation
-
-```bash
-pip install python-fragments
-```
-
-Register the loader at your application's entry point, before importing any modules that contain fragments:
-
-```python
-from fragments import loader  # isort: skip
-```
-
-Any `.py` file containing `<>` is transpiled automatically. Nothing else to configure.

python_fragments-0.28/python_fragments.egg-info/PKG-INFO

@@ -1,55 +0,0 @@
-Metadata-Version: 2.4
-Name: python-fragments
-Version: 0.28
-Summary: Modern HTML template rendering in Python
-Author-email: The Running Algorithm <services@therunningalgorithm.info>
-License: Proprietary
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-Provides-Extra: lsp
-Requires-Dist: basedpyright>=1.39.0; extra == "lsp"
-Requires-Dist: lsprotocol>=2025.0.0; extra == "lsp"
-Provides-Extra: dev
-Requires-Dist: pytest>=8.4.1; extra == "dev"
-
-# Python Fragments
-
-> **This package is in early development and not yet stable. The API may change without notice between releases.**
-
-Production-ready, modern HTML template rendering in Python — no build step, no template files, and native HTML awareness out of the box.
-
-```python
-from fragments import loader  # isort: skip
-
-from fastapi import FastAPI
-from fastapi.responses import HTMLResponse
-from components import Layout, PostCard
-
-app = FastAPI()
-
-POSTS = [...]
-
-@app.get("/", response_class=HTMLResponse)
-async def index() -> str:
-    published = [p for p in POSTS if p.published]
-    return <>
-        <Layout title="My Blog">
-            <h1>Latest Posts</h1>
-            <PostCard for={{ post in published }} post={{ post }} />
-        </Layout>
-    </>
-```
-
-## Installation
-
-```bash
-pip install python-fragments
-```
-
-Register the loader at your application's entry point, before importing any modules that contain fragments:
-
-```python
-from fragments import loader  # isort: skip
-```
-
-Any `.py` file containing `<>` is transpiled automatically. Nothing else to configure.