htmy 0.3.5__py3-none-any.whl → 0.4.0__py3-none-any.whl

htmy/__init__.py

@@ -15,7 +15,7 @@ from .core import WithContext as WithContext
 from .core import XBool as XBool
 from .core import component as component
 from .core import xml_format_string as xml_format_string
-from .renderer import HTMY as HTMY
+from .renderer import Renderer as Renderer
 from .typing import AsyncComponent as AsyncComponent
 from .typing import AsyncContextProvider as AsyncContextProvider
 from .typing import AsyncFunctionComponent as AsyncFunctionComponent
@@ -36,3 +36,6 @@ from .typing import SyncContextProvider as SyncContextProvider
 from .typing import SyncFunctionComponent as SyncFunctionComponent
 from .typing import is_component_sequence as is_component_sequence
 from .utils import join_components as join_components
+
+HTMY = Renderer
+"""Deprecated alias for `Renderer`."""

htmy/core.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import abc
 import asyncio
 import enum
-from collections.abc import Callable, Container
+from collections.abc import Awaitable, Callable, Container
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypedDict, cast, overload
 from xml.sax.saxutils import escape as xml_escape
@@ -21,6 +21,7 @@ from .typing import (
     PropertyValue,
     SyncFunctionComponent,
     T,
+    TextProcessor,
     is_component_sequence,
 )
 from .utils import join_components
@@ -121,7 +122,7 @@ class WithContext(Fragment):
         self._context = context
 
     def htmy_context(self) -> Context:
-        """Returns an HTMY context for child rendering."""
+        """Returns the context for child rendering."""
         return self._context
 
 
@@ -130,21 +131,34 @@ class Snippet:
     Base component that can load its content from a file.
     """
 
-    __slots__ = ("_path_or_text",)
+    __slots__ = ("_path_or_text", "_text_processor")
 
-    def __init__(self, path_or_text: Text | str | Path) -> None:
+    def __init__(
+        self,
+        path_or_text: Text | str | Path,
+        *,
+        text_processor: TextProcessor | None = None,
+    ) -> None:
         """
         Initialization.
 
         Arguments:
             path_or_text: The path from where the content should be loaded or a `Text`
                 instance if this value should be rendered directly.
+            text_processor: An optional text processors that can be used to process the text
+                content before rendering. It can be used for example for token replacement or
+                string formatting.
         """
         self._path_or_text = path_or_text
+        self._text_processor = text_processor
 
     async def htmy(self, context: Context) -> Component:
         """Renders the component."""
         text = await self._get_text_content()
+        if self._text_processor is not None:
+            processed = self._text_processor(text, context)
+            text = (await processed) if isinstance(processed, Awaitable) else processed
+
         return self._render_text(text, context)
 
     async def _get_text_content(self) -> str:
@@ -160,7 +174,7 @@ class Snippet:
     def _render_text(self, text: str, context: Context) -> Component:
         """
         Render function that takes the text that must be rendered and the current rendering context,
-        and returns the corresponding HTMY component.
+        and returns the corresponding component.
         """
         return SafeStr(text)
 
@@ -509,7 +523,7 @@ class BaseTag(abc.ABC):
 
     @abc.abstractmethod
     def htmy(self, context: Context) -> Component:
-        """Abstract base method for HTMY rendering."""
+        """Abstract base component implementation."""
         ...
 
     def _get_htmy_name(self) -> str:

htmy/etree.py

@@ -17,7 +17,7 @@ from htmy.core import Fragment, SafeStr, WildcardTag
 
 class ETreeConverter:
     """
-    Utility for converting XML strings to custom HTMY components.
+    Utility for converting XML strings to custom components.
     """
 
     __slots__ = ("_rules",)
@@ -33,12 +33,12 @@ class ETreeConverter:
         Initialization.
 
         Arguments:
-            rules: Tag-name to HTMY component conversion rules.
+            rules: Tag-name to component conversion rules.
         """
         self._rules = rules
 
     def convert(self, element: str) -> ComponentType:
-        """Converts the given (possible multi-root) XML string to an HTMY component."""
+        """Converts the given (possibly multi-root) XML string to a component."""
         if len(self._rules) == 0:
             return SafeStr(element)
 
@@ -46,7 +46,7 @@ class ETreeConverter:
         return self.convert_element(ET.fromstring(element))  # noqa: S314 # Only use from XML strings from a trusted source.
 
     def convert_element(self, element: Element) -> ComponentType:
-        """Converts the given `Element` to an HTMY component."""
+        """Converts the given `Element` to a component."""
         rules = self._rules
         if len(rules) == 0:
             return SafeStr(ET.tostring(element))
@@ -67,7 +67,7 @@ class ETreeConverter:
 
     def _convert_properties(self, element: Element) -> Properties:
         """
-        Converts the attributes of the given `Element` to an HTMY `Properties` mapping.
+        Converts the attributes of the given `Element` to a `Properties` mapping.
 
         This method should not alter property names in any way.
         """
@@ -75,8 +75,8 @@ class ETreeConverter:
 
     def _convert_children(self, element: Element) -> Generator[ComponentType, None, None]:
         """
-        Generator that converts all (text and `Element`) children of the given `Element`
-        into an HTMY component."""
+        Generator that converts all (text and `Element`) children of the given `Element` to a component.
+        """
         if text := self._process_text(element.text):
             yield text
 

htmy/md/core.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, ClassVar
 from markdown import Markdown
 
 from htmy.core import ContextAware, SafeStr, Snippet, Text
+from htmy.typing import TextProcessor
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -90,6 +91,7 @@ class MD(Snippet):
         *,
         converter: Callable[[str], Component] | None = None,
         renderer: MarkdownRenderFunction | None = None,
+        text_processor: TextProcessor | None = None,
     ) -> None:
         """
         Initialization.
@@ -97,11 +99,14 @@ class MD(Snippet):
         Arguments:
             path_or_text: The path where the markdown file is located or a markdown `Text`.
             converter: Function that converts an HTML string (the parsed and processed markdown text)
-                into an HTMY component.
-            renderer: Function that get the parsed and converted content and the metadata (if it exists)
-                and turns them into an HTMY component.
+                into a component.
+            renderer: Function that gets the parsed and converted content and the metadata (if it exists)
+                and turns them into a component.
+            text_processor: An optional text processors that can be used to process the text
+                content before rendering. It can be used for example for token replacement or
+                string formatting.
         """
-        super().__init__(path_or_text)
+        super().__init__(path_or_text, text_processor=text_processor)
         self._converter: Callable[[str], Component] = SafeStr if converter is None else converter
         self._renderer = renderer
 

htmy/renderer/__init__.py

@@ -0,0 +1,8 @@
+from .baseline import Renderer as _BaselineRenderer
+from .default import Renderer as _DefaultRenderer
+
+Renderer = _DefaultRenderer
+"""The default renderer."""
+
+BaselineRenderer = _BaselineRenderer
+"""The baseline renderer."""

htmy/{renderer.py → renderer/baseline.py}

@@ -4,12 +4,21 @@ import asyncio
 from collections import ChainMap
 from collections.abc import Awaitable, Callable, Iterable
 
-from .core import ErrorBoundary, xml_format_string
-from .typing import Component, ComponentType, Context
+from htmy.core import ErrorBoundary, xml_format_string
+from htmy.typing import Component, ComponentType, Context
 
 
-class HTMY:
-    """HTMY component renderer."""
+class Renderer:
+    """
+    The baseline component renderer.
+
+    Because of the simple, recursive implementation, this renderer is the easiest to reason about.
+    Therefore it is useful for validating component correctness before bug reporting (if another
+    renderer implementation fails), testing and debugging alternative implementations, and it can
+    also serve as the baseline for benchmarking optimized renderers.
+
+    The performance of this renderer is not production quality.
+    """
 
     __slots__ = ("_default_context", "_string_formatter")
 

htmy/renderer/default.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import asyncio
+from collections import ChainMap, deque
+from collections.abc import Awaitable, Callable, Iterator
+from typing import TypeAlias
+
+from htmy.core import ErrorBoundary, xml_format_string
+from htmy.typing import Component, ComponentType, Context, ContextProvider, is_component_sequence
+
+
+class _Node:
+    """A single node in the linked list the renderer constructs to resolve a component tree."""
+
+    __slots__ = ("component", "next")
+
+    def __init__(self, component: ComponentType, next: _Node | None = None) -> None:
+        """
+        Initialization.
+
+        Arguments:
+            component: The component in this node.
+            next: The next component in the list, if there is one.
+        """
+        self.component = component
+        self.next = next
+
+    def iter_nodes(self, *, include_self: bool = True) -> Iterator[_Node]:
+        """
+        Iterates over all following nodes.
+
+        Arguments:
+            include_self: Whether the node on which this method is called should also
+                be included in the iterator.
+        """
+        current = self if include_self else self.next
+        while current is not None:
+            yield current
+            current = current.next
+
+
+_NodeAndChildContext: TypeAlias = tuple[_Node, Context]
+
+
+class _ComponentRenderer:
+    """
+    `ComponentType` renderer that converts a component tree into a linked list of resolved (`str`) nodes.
+    """
+
+    __slots__ = ("_async_todos", "_error_boundary_todos", "_sync_todos", "_root", "_string_formatter")
+
+    def __init__(
+        self,
+        component: ComponentType,
+        context: Context,
+        *,
+        string_formatter: Callable[[str], str],
+    ) -> None:
+        """
+        Initialization.
+
+        Arguments:
+            component: The component to render.
+            context: The base context to use for rendering the component.
+            string_formatter: The string formatter to use.
+        """
+        self._async_todos: deque[_NodeAndChildContext] = deque()
+        """Async node - context tuples that need to be rendered."""
+        self._error_boundary_todos: deque[_NodeAndChildContext] = deque()
+        """Node context tuples where `node.component` is an `ErrorBoundary`."""
+        self._sync_todos: deque[_NodeAndChildContext] = deque()
+        """
+        Sync node - context tuples that need to be rendered (`node.component` is an `HTMYComponentType`).
+        """
+        self._string_formatter = string_formatter
+        """The string formatter to use."""
+
+        if isinstance(component, str):
+            root = _Node(string_formatter(component), None)
+        else:
+            root = _Node(component, None)
+            self._schedule_node(root, context)
+        self._root = root
+        """The root node in the linked list the renderer constructs."""
+
+    async def _extend_context(self, component: ContextProvider, context: Context) -> Context:
+        """
+        Returns a new context from the given component and context.
+
+        Arguments:
+            component: A `ContextProvider` component.
+            context: The current rendering context.
+        """
+        extra_context: Context | Awaitable[Context] = component.htmy_context()
+        if isinstance(extra_context, Awaitable):
+            extra_context = await extra_context
+
+        return (
+            # Context must not be mutated. We can ignore that ChainMap expects mutable mappings.
+            ChainMap(extra_context, context)  # type: ignore[arg-type]
+            if extra_context
+            else context
+        )
+
+    async def _process_error_boundary(self, node: _Node, context: Context) -> None:
+        """
+        Processes a single node whose component is an `ErrorBoundary`.
+        """
+        component: ErrorBoundary = node.component  # type: ignore[assignment]
+        if hasattr(component, "htmy_context"):  # isinstance() is too expensive.
+            context = await self._extend_context(component, context)
+
+        try:
+            result = await _render_component(
+                component.htmy(context),
+                context=context,
+                string_formatter=self._string_formatter,
+            )
+        except Exception as e:
+            renderer = _ComponentRenderer(
+                component.fallback_component(e),
+                context,
+                string_formatter=self._string_formatter,
+            )
+            result = await renderer.run()
+
+        node.component = result  # No string formatting.
+
+    def _process_node_result(self, parent_node: _Node, component: Component, context: Context) -> None:
+        """
+        Processes the result of a single node.
+
+        Arguments:
+            parent_node: The node that was resolved.
+            component: The (awaited if async) result of `parent_node.component.htmy()`.
+            context: The context that was used for rendering `parent_node.component`.
+        """
+        schedule_node = self._schedule_node
+        string_formatter = self._string_formatter
+        if is_component_sequence(component):
+            if len(component) == 0:
+                parent_node.component = ""
+                return
+
+            first_comp, *rest_comps = component
+            if isinstance(first_comp, str):
+                parent_node.component = string_formatter(first_comp)
+            else:
+                parent_node.component = first_comp
+                schedule_node(parent_node, context)
+
+            old_next = parent_node.next
+            last: _Node = parent_node
+            for c in rest_comps:
+                if isinstance(c, str):
+                    node = _Node(string_formatter(c), old_next)
+                else:
+                    node = _Node(c, old_next)
+                    schedule_node(node, context)
+
+                last.next = node
+                last = node
+        elif isinstance(component, str):
+            parent_node.component = string_formatter(component)
+        else:
+            parent_node.component = component  # type: ignore[assignment]
+            schedule_node(parent_node, context)
+
+    async def _process_async_node(self, node: _Node, context: Context) -> None:
+        """
+        Processes the given node. `node.component` must be an async component.
+        """
+        result = await node.component.htmy(context)  # type: ignore[misc,union-attr]
+        self._process_node_result(node, result, context)
+
+    def _schedule_node(self, node: _Node, child_context: Context) -> None:
+        """
+        Schedules the given node for rendering with the given child context.
+
+        `node.component` must be an `HTMYComponentType` (single component and not `str`).
+        """
+        component = node.component
+        if asyncio.iscoroutinefunction(component.htmy):  # type: ignore[union-attr]
+            self._async_todos.append((node, child_context))
+        elif isinstance(component, ErrorBoundary):
+            self._error_boundary_todos.append((node, child_context))
+        else:
+            self._sync_todos.append((node, child_context))
+
+    async def run(self) -> str:
+        """Runs the component renderer."""
+        async_todos = self._async_todos
+        sync_todos = self._sync_todos
+        process_node_result = self._process_node_result
+        process_async_node = self._process_async_node
+
+        while sync_todos or async_todos:
+            while sync_todos:
+                node, child_context = sync_todos.pop()
+                component = node.component
+                if hasattr(component, "htmy_context"):  # isinstance() is too expensive.
+                    child_context = await self._extend_context(component, child_context)  # type: ignore[arg-type]
+
+                if asyncio.iscoroutinefunction(node.component.htmy):  # type: ignore[union-attr]
+                    async_todos.append((node, child_context))
+                else:
+                    result: Component = node.component.htmy(child_context)  # type: ignore[assignment,union-attr]
+                    process_node_result(node, result, child_context)
+
+            if async_todos:
+                await asyncio.gather(*(process_async_node(n, ctx) for n, ctx in async_todos))
+                async_todos.clear()
+
+        if self._error_boundary_todos:
+            await asyncio.gather(
+                *(self._process_error_boundary(n, ctx) for n, ctx in self._error_boundary_todos)
+            )
+
+        return "".join(node.component for node in self._root.iter_nodes())  # type: ignore[misc]
+
+
+async def _render_component(
+    component: Component,
+    *,
+    context: Context,
+    string_formatter: Callable[[str], str],
+) -> str:
+    """Renders the given component with the given settings."""
+    if is_component_sequence(component):
+        if len(component) == 0:
+            return ""
+
+        renderers = (_ComponentRenderer(c, context, string_formatter=string_formatter) for c in component)
+        return "".join(await asyncio.gather(*(r.run() for r in renderers)))
+    else:
+        return await _ComponentRenderer(component, context, string_formatter=string_formatter).run()  # type: ignore[arg-type]
+
+
+class Renderer:
+    """
+    The default renderer.
+
+    It resolves component trees by converting them to a linked list of resolved component parts
+    before combining them to the final string.
+    """
+
+    __slots__ = ("_default_context", "_string_formatter")
+
+    def __init__(
+        self,
+        default_context: Context | None = None,
+        *,
+        string_formatter: Callable[[str], str] = xml_format_string,
+    ) -> None:
+        """
+        Initialization.
+
+        Arguments:
+            default_context: The default context to use for rendering if `render()` doesn't
+                receive a context.
+            string_formatter: Callable that should be used to format plain strings. By default
+                an XML-safe string formatter will be used.
+        """
+        self._default_context: Context = {} if default_context is None else default_context
+        self._string_formatter = string_formatter
+
+    async def render(self, component: Component, context: Context | None = None) -> str:
+        """
+        Renders the given component.
+
+        Arguments:
+            component: The component to render.
+            context: An optional rendering context.
+
+        Returns:
+            The rendered string.
+        """
+        # Type ignore: ChainMap expects mutable mappings, but context mutation is not allowed so don't care.
+        context = (
+            self._default_context if context is None else ChainMap(context, self._default_context)  # type: ignore[arg-type]
+        )
+        return await _render_component(component, context=context, string_formatter=self._string_formatter)

htmy/typing.py

@@ -88,7 +88,7 @@ class SyncContextProvider(Protocol):
     """Protocol definition for sync context providers."""
 
     def htmy_context(self) -> Context:
-        """Returns an HTMY context for child rendering."""
+        """Returns a context for child rendering."""
         ...
 
 
@@ -97,9 +97,15 @@ class AsyncContextProvider(Protocol):
     """Protocol definition for async context providers."""
 
     async def htmy_context(self) -> Context:
-        """Returns an HTMY context for child rendering."""
+        """Returns a context for child rendering."""
         ...
 
 
 ContextProvider: TypeAlias = SyncContextProvider | AsyncContextProvider
 """Context provider type."""
+
+
+# -- Text processors
+
+TextProcessor: TypeAlias = Callable[[str, Context], str | Coroutine[Any, Any, str]]
+"""Callable type that expects a string and a context, and returns a processed string."""

{htmy-0.3.5.dist-info → htmy-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: htmy
-Version: 0.3.5
+Version: 0.4.0
 Summary: Async, pure-Python rendering engine.
 License: MIT
 Author: Peter Volf
@@ -170,16 +170,16 @@ user_table = html.table(
 
 ### Rendering
 
-`htmy.HTMY` is the built-in, default renderer of the library.
+`htmy.Renderer` is the built-in, default renderer of the library.
 
-If you're using the library in an async web framework like [FastAPI](https://fastapi.tiangolo.com/), then you're already in an async environment, so you can render components as simply as this: `await HTMY().render(my_root_component)`.
+If you're using the library in an async web framework like [FastAPI](https://fastapi.tiangolo.com/), then you're already in an async environment, so you can render components as simply as this: `await Renderer().render(my_root_component)`.
 
 If you're trying to run the renderer in a sync environment, like a local script or CLI, then you first need to wrap the renderer in an async task and execute that task with `asyncio.run()`:
 
 ```python
 import asyncio
 
-from htmy import HTMY, html
+from htmy import Renderer, html
 
 async def render_page() -> None:
     page = (
@@ -192,7 +192,7 @@ async def render_page() -> None:
         )
     )
 
-    result = await HTMY().render(page)
+    result = await Renderer().render(page)
     print(result)
 
 
@@ -213,7 +213,7 @@ Here's an example context provider and consumer implementation:
 ```python
 import asyncio
 
-from htmy import HTMY, Component, ComponentType, Context, component, html
+from htmy import Component, ComponentType, Context, Renderer, component, html
 
 class UserContext:
     def __init__(self, *children: ComponentType, username: str, theme: str) -> None:
@@ -259,7 +259,7 @@ async def render_welcome_page() -> None:
         theme="dark",
     )
 
-    result = await HTMY().render(page)
+    result = await Renderer().render(page)
     print(result)
 
 if __name__ == "__main__":
@@ -270,7 +270,7 @@ You can of course rely on the built-in context related utilities like the `Conte
 
 ### Formatter
 
-As mentioned before, the built-in `Formatter` class is responsible for tag attribute name and value formatting. You can completely override or extend the built-in formatting behavior simply by extending this class or adding new rules to an instance of it, and then adding the custom instance to the context, either directly in `HTMY` or `HTMY.render()`, or in a context provider component.
+As mentioned before, the built-in `Formatter` class is responsible for tag attribute name and value formatting. You can completely override or extend the built-in formatting behavior simply by extending this class or adding new rules to an instance of it, and then adding the custom instance to the context, either directly in `Renderer` or `Renderer.render()`, or in a context provider component.
 
 These are default tag attribute formatting rules:
 

htmy-0.4.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+htmy/__init__.py,sha256=yMPXQHkXQCjyx7UUVcfsMQ_5YjvNT62Kb9TI1xEcw2A,1899
+htmy/core.py,sha256=5V019PwIes9Eyzu0eWwsvBZNZ6x7DhQy9y99myCw9A0,19322
+htmy/etree.py,sha256=yKxom__AdsJY-Q1kbU0sdTMr0ZF5dMSVBKxayntNFyQ,3062
+htmy/html.py,sha256=pxmE-KU5OgwNp6MyxOfdS0Ohpzu2RNYCeGGFlHLDGUM,20940
+htmy/i18n.py,sha256=brNazQjObBFfbnViZCpcnxa0qgxQbJfX7xJAH-MqTW8,5124
+htmy/io.py,sha256=iebJOZp7L0kZ9SWdqMatKtW5VGRIkEd-eD0_vTAldH8,41
+htmy/md/__init__.py,sha256=lxBJnYplkDuxYuiese6My9KYp1DeGdzo70iUdYTvMnE,334
+htmy/md/core.py,sha256=EK-QoB2BIra3o1nvTK0lGP3mQQPtRXuE6zBKF_IWR_o,3675
+htmy/md/typing.py,sha256=LF-AEvo7FCW2KumyR5l55rsXizV2E4AHVLKFf6lApgM,762
+htmy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+htmy/renderer/__init__.py,sha256=xnP_aaoK-pTok-69wi8O_xlsgjoKTzWd2lIIeHGcuaY,226
+htmy/renderer/baseline.py,sha256=hHb7CoQhFFdD7Sdw0ltR1-XLGwE9pqmfL5yKFeF2rCg,4288
+htmy/renderer/default.py,sha256=rdx-yFYz-cz197xfe9co8Lru2cdZxAjOO4dqY250Y1Q,10767
+htmy/typing.py,sha256=f4QZ8vQL7JfN402yDb8Hq_DYvQS_GUgdXK8-xTBM8y8,3122
+htmy/utils.py,sha256=7_CyA39l2m6jzDqparPKkKgRB2wiGuBZXbiPgiZOXKA,1093
+htmy-0.4.0.dist-info/LICENSE,sha256=rFtoGU_3c_rlacXgOZapTHfMErN-JFPT5Bq_col4bqI,1067
+htmy-0.4.0.dist-info/METADATA,sha256=kuRCDnI6icrwlaYUOuK9FAe__t5aqjOX8_QTtqN6vNU,16379
+htmy-0.4.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+htmy-0.4.0.dist-info/RECORD,,

htmy-0.3.5.dist-info/RECORD

@@ -1,17 +0,0 @@
-htmy/__init__.py,sha256=My_Dmh9JNQpQekTO6CEbdbV7Ux7MD9Pz-L2M3KMZjGQ,1835
-htmy/core.py,sha256=JZNryJU1VCAVBf1wzkaa9bD3LiepT-Eu28XydfbWpOw,18735
-htmy/etree.py,sha256=zZkKY82t5fX85unS9oHuG6KEBsJY_iz6E7SJto8lSVQ,3097
-htmy/html.py,sha256=pxmE-KU5OgwNp6MyxOfdS0Ohpzu2RNYCeGGFlHLDGUM,20940
-htmy/i18n.py,sha256=brNazQjObBFfbnViZCpcnxa0qgxQbJfX7xJAH-MqTW8,5124
-htmy/io.py,sha256=iebJOZp7L0kZ9SWdqMatKtW5VGRIkEd-eD0_vTAldH8,41
-htmy/md/__init__.py,sha256=lxBJnYplkDuxYuiese6My9KYp1DeGdzo70iUdYTvMnE,334
-htmy/md/core.py,sha256=-EKucDFKMUtGgs9k_q9134oXY2GXtdKX1KOJXG4YmKc,3342
-htmy/md/typing.py,sha256=LF-AEvo7FCW2KumyR5l55rsXizV2E4AHVLKFf6lApgM,762
-htmy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-htmy/renderer.py,sha256=vCYqq83RaEtlXKDGWB6LgKjoE1TSfMfB5TW1lJWHE5c,3829
-htmy/typing.py,sha256=iUZQjMU-DHMV1Mv-ugW26eSPlrFO-KVhWfkLod7dig4,2937
-htmy/utils.py,sha256=7_CyA39l2m6jzDqparPKkKgRB2wiGuBZXbiPgiZOXKA,1093
-htmy-0.3.5.dist-info/LICENSE,sha256=rFtoGU_3c_rlacXgOZapTHfMErN-JFPT5Bq_col4bqI,1067
-htmy-0.3.5.dist-info/METADATA,sha256=emcRbV2rYZ_RP4LqKGjzv3WBdadUpyQREdujGyycXt0,16347
-htmy-0.3.5.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-htmy-0.3.5.dist-info/RECORD,,