compone 0.1.0__tar.gz

compone-0.1.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: compone
+Version: 0.1.0
+Summary: Component framework for Python
+License: MIT
+Author: György Kiss
+Author-email: gyorgy@duck.com
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: markupsafe (>=2.1.5,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Compone
+
+Compone is a **Python component framework** inspired by React, that allows for
+type-safe HTML generation. It is an alternative to Python template engines,
+using Python objects instead of strings. This way you get Exception tracebacks
+for mistyped HTML tags and attributes instead of malformed HTML!
+

compone-0.1.0/README.md

@@ -0,0 +1,6 @@
+# Compone
+
+Compone is a **Python component framework** inspired by React, that allows for
+type-safe HTML generation. It is an alternative to Python template engines,
+using Python objects instead of strings. This way you get Exception tracebacks
+for mistyped HTML tags and attributes instead of malformed HTML!

compone-0.1.0/compone/__init__.py

@@ -0,0 +1,3 @@
+# ruff: noqa: F401
+from .component import Component
+from .escape import escape, safe

compone-0.1.0/compone/component.py

@@ -0,0 +1,409 @@
+import copy
+import inspect
+import keyword
+from contextvars import ContextVar
+from functools import cached_property
+from types import MappingProxyType
+from typing import Callable, Iterable, List, Optional, Protocol, Type, TypeVar, Union
+
+from .escape import escape, safe
+from .utils import _is_iterable
+
+# previous frame id (frame.f_back), parent object
+last_parent = ContextVar("last_parent", default=(None, None))
+
+T = TypeVar("T")
+CompSelf = TypeVar("CompSelf", bound="_ComponentBase")
+ChildSelf = TypeVar("ChildSelf", bound="_ChildrenBase")
+StrType = Union[str, safe]
+ContentType = Union[StrType, CompSelf]
+
+
+class ComponentClass(Protocol):
+    def render(self, children: safe) -> Union[ContentType, Iterable[ContentType]]:
+        ...
+
+
+class _ComponentBase:
+    _sig: inspect.Signature
+    _positional_args: List[str]
+    _var_keyword: Optional[str]
+
+    def __init__(self, *args, **kwargs):
+        self._bound_args = self._bind_args(*args, **kwargs)
+
+    def _bind_args(self, *args, **kwargs):
+        bound = self._sig.bind(*args, **kwargs)
+        bound.apply_defaults()
+        return bound
+
+    @cached_property
+    def props(self) -> dict:
+        kwargs = {k: v for k, v in self._bound_args.kwargs.items() if v is not None}
+        args = {
+            k: v
+            for k, v in self._bound_args.arguments.items()
+            if k not in kwargs and v is not None
+        }
+        if self._var_keyword is not None:
+            del args[self._var_keyword]
+        return MappingProxyType({**args, **kwargs})
+
+    def replace(self, **kwargs) -> CompSelf:
+        self._check_common_props(kwargs)
+        return self._make_new(kwargs)
+
+    def append(self, **kwargs) -> CompSelf:
+        self._check_common_props(kwargs)
+        appended = {key: (self.props[key] + val) for key, val in kwargs.items()}
+        return self._make_new(appended)
+
+    def _check_common_props(self, kwargs):
+        if not set(kwargs) & set(self.props):
+            kwargs_list = ", ".join(repr(k) for k in kwargs.keys())
+            raise TypeError(f"{self!r} has no existing props for {kwargs_list}")
+
+    def __call__(self, *args, **kwargs) -> CompSelf:
+        # Replaces existing props, set new ones
+        args_only = {name: newval for name, newval in zip(self._positional_args, args)}
+        return self._make_new({**args_only, **kwargs})
+
+    def _make_new(self, new_arguments) -> CompSelf:
+        arguments_copy = {
+            k: copy.copy(v) for k, v in self._bound_args.arguments.items()
+        }
+        bound_copy = inspect.BoundArguments(self._sig, arguments_copy)
+
+        if self._var_keyword is None:
+            bound_copy.arguments.update(new_arguments)
+        else:
+            old_star_arguments = bound_copy.arguments[self._var_keyword]
+            new_star_arguments = {
+                k: v for k, v in new_arguments.items() if k in old_star_arguments
+            }
+            old_star_arguments.update(new_star_arguments)
+
+            other_arguments = {
+                k: v for k, v in new_arguments.items() if k not in new_star_arguments
+            }
+            bound_copy.arguments.update(other_arguments)
+
+        # This is to add new kwargs that was not specified before
+        # It will raise TypeError for args not in self._sig
+        extra_kwargs = {
+            k: v
+            for k, v in new_arguments.items()
+            if k not in bound_copy.kwargs and k not in self._positional_args
+        }
+        new_kwargs = {**bound_copy.kwargs, **extra_kwargs}
+        new_bound = self._bind_args(*bound_copy.args, **new_kwargs)
+        return self.__class__(*new_bound.args, **new_bound.kwargs)
+
+    def __repr__(self):
+        if self.props:
+            proplist = ", ".join(f"{k}={v!r}" for k, v in self.props.items())
+        else:
+            proplist = ""
+        return f"<{self.__class__.__name__}({proplist})>"
+
+    def __mul__(self, other: int) -> CompSelf:
+        if not isinstance(other, int):
+            return NotImplemented
+
+        # Every component is safe by default, so the result should be safe too
+        Multiple = Component(lambda: safe(self) * other)
+        Multiple.__name__ = "Multi" + self.__class__.__name__
+        Multiple.__doc__ = "Multiple: " + (self.__doc__ or "")
+        return Multiple()
+
+
+class _ChildrenBase(_ComponentBase):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._children = []
+
+    def __enter__(self) -> ChildSelf:
+        parent_frame_id, parent = last_parent.get()
+        self._parent_frame_id = parent_frame_id
+        self._parent = parent
+        current_frame_id = id(inspect.currentframe().f_back)
+        last_parent.set((current_frame_id, self))
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        current_frame_id = id(inspect.currentframe().f_back)
+        if self._parent is not None and current_frame_id == self._parent_frame_id:
+            self._parent._children.append(self)
+        last_parent.set((self._parent_frame_id, self._parent))
+
+    def __iadd__(self, other) -> ChildSelf:
+        self._children.append(other)
+        return self
+
+    def __class_getitem__(cls, key) -> ChildSelf:
+        return cls()[key]
+
+    def __getitem__(self, children) -> safe:
+        if self._children:
+            # Not AttributeError because it would be confusing,
+            # for example when using hasattr.
+            # Also this is like a function call, so ValueError makes sense
+            raise ValueError(
+                "Component already has children, "
+                "use the += operator if you want to add more."
+            )
+
+        if _is_iterable(children):
+            # str is a special case, because it's an iterator too.
+            # _ChildrenBase are also iterators because of this very method
+            if isinstance(children, (str, safe, _ChildrenBase)):
+                children = (children,)
+        else:
+            children = (children,)
+
+        new = self.__class__(*self._bound_args.args, **self._bound_args.kwargs)
+        new._children = children
+        return new
+
+    @property
+    def children(self):
+        return tuple(self._children)
+
+    def __call__(self, *args, **kwargs) -> CompSelf:
+        if self._children:
+            raise ValueError("Component already has children, cannot replace them.")
+        return super().__call__(*args, **kwargs)
+
+    def __eq__(self, other):
+        if not isinstance(other, _ChildrenBase):
+            return NotImplemented
+        # This is the safest way to do this, because user-implemented,
+        # class-based Components can have different properties, which
+        # might render them differently. We can't compare those without rendering.
+        return str(self) == str(other)
+
+    def __str__(self) -> safe:
+        safe_children = self._escape(self._children) if self._children else safe()
+        content = self._render(safe_children)
+        return self._escape(content)
+
+    @classmethod
+    def _escape(cls, item) -> safe:
+        if isinstance(item, (str, _ComponentBase)):
+            return escape(item)
+        elif _is_iterable(item):
+            return safe("".join(cls._escape(e) for e in item))
+        else:
+            return escape(item)
+
+
+class _FuncComponent(_ChildrenBase):
+    _func: Callable
+    _pass_children: bool
+
+    def _render(self, children: safe) -> Union[ContentType, Iterable[ContentType]]:
+        # BoundArguments.kwargs is a property, this makes a copy
+        kwargs = self._bound_args.kwargs
+
+        if self._pass_children:
+            kwargs["children"] = children
+
+        # self.func is unbound
+        content = self.__class__._func(*self._bound_args.args, **kwargs)
+        return content
+
+
+class _ClassComponent(_ChildrenBase):
+    _pass_children: bool
+    _user_class: ComponentClass
+
+    @cached_property
+    def _user_instance(self) -> ComponentClass:
+        return self._user_class(*self._bound_args.args, **self._bound_args.kwargs)
+
+    def _render(self, children: safe):
+        if self._pass_children:
+            return self._user_instance.render(children)
+        else:
+            return self._user_instance.render()
+
+
+class _HTMLComponentBase(_ComponentBase):
+    _html_tag: str
+    _attributes = None
+    _sig = inspect.signature(lambda **kwargs: None)
+    _var_keyword = "kwargs"
+    _positional_args = []
+
+    def __init__(self, **kwargs):
+        if self._attributes is not None:
+            kwargs.update(self._attributes)
+        self._original_kwargs = kwargs
+        self._convert_class(kwargs)
+        super().__init__(**kwargs)
+
+    @staticmethod
+    def _convert_class(kwargs) -> list:
+        class_ = kwargs.get("class_", None)
+        if isinstance(class_, str):
+            kwargs["class_"] = class_.split()
+        elif isinstance(class_, (list, tuple)):
+            kwargs["class_"] = [c.strip() for c in class_]
+
+    def append(self, **kwargs) -> CompSelf:
+        self._convert_class(kwargs)
+        return super().append(**kwargs)
+
+    def _get_attributes(self) -> str:  # noqa: C901
+        bool_args = []
+        keyval_args = []
+
+        for key, val in self.props.items():
+            if isinstance(val, str) and '"' in val and "'" in val:
+                raise ValueError("Both single and double quotes in attribute value")
+            if keyword.iskeyword(no_underscore := key[:-1]):
+                key = no_underscore
+            if isinstance(val, (list, tuple)):
+                val = " ".join(str(i) for i in val)
+
+            html_key = escape(key.replace("_", "-"))
+
+            if isinstance(val, bool):
+                # by HTML standard, False values must not be included in attributes
+                if not val:
+                    continue
+                bool_args.append(html_key)
+            else:
+                html_val = escape(val)
+                if '"' in html_val:
+                    html_attr = f"{html_key}='{html_val}'"
+                else:
+                    html_attr = f'{html_key}="{html_val}"'
+                keyval_args.append(html_attr)
+
+        bool_prefix = " " if bool_args else ""
+        bool_arguments = " ".join(bool_args)
+
+        keyval_prefix = " " if keyval_args else ""
+        keyval_arguments = " ".join(keyval_args)
+
+        return bool_prefix + bool_arguments + keyval_prefix + keyval_arguments
+
+
+class _HTMLComponent(_HTMLComponentBase, _ChildrenBase):
+    def _render(self, children: safe) -> safe:
+        attributes = self._get_attributes()
+        return safe(f"<{self._html_tag}{attributes}>{children}</{self._html_tag}>")
+
+
+class _SelfClosingHTMLComponent(_HTMLComponentBase):
+    def __str__(self) -> safe:
+        attributes = self._get_attributes()
+        return safe(f"<{self._html_tag}{attributes} />")
+
+    def __eq__(self, other):
+        if not isinstance(other, _SelfClosingHTMLComponent):
+            return NotImplemented
+        return (
+            # It's a little bit cheaper to compare this way than rendering
+            self._html_tag == other._html_tag
+            and self._original_kwargs == other._original_kwargs
+        )
+
+
+def Component(
+    func_or_class: Union[ComponentClass, Callable],
+) -> Union[Type[_ClassComponent], Type[_FuncComponent]]:
+    if inspect.isfunction(func_or_class):
+        return _make_func_component(func_or_class)
+    elif inspect.isclass(func_or_class):
+        return _make_class_component(func_or_class)
+    else:
+        raise TypeError("Components can only be classes or functions")
+
+
+def _make_sig(func):
+    sig = inspect.signature(func)
+    # This is only for caching in the class
+    positional_args = [
+        name
+        for name, param in sig.parameters.items()
+        if param.kind in {param.POSITIONAL_ONLY, param.POSITIONAL_OR_KEYWORD}
+    ]
+    return sig, positional_args
+
+
+def _get_var_keyword(sig) -> Optional[str]:
+    try:
+        return next(p.name for p in sig.parameters.values() if p.kind == p.VAR_KEYWORD)
+    except StopIteration:
+        return None
+
+
+def _make_class_component(user_class: ComponentClass) -> Type[_ClassComponent]:
+    if not hasattr(user_class, "render"):
+        raise TypeError(f"{user_class.__name__} doesn't have a .render() method.")
+
+    orig_sig, positional_args = _make_sig(user_class.__init__)
+    without_passed = [
+        param
+        for key, param in orig_sig.parameters.items()
+        if key not in {"self", "children"}
+    ]
+    sig = inspect.Signature(parameters=without_passed)
+    render_sig = inspect.signature(user_class.render)
+
+    return type(
+        user_class.__name__,
+        (_ClassComponent,),
+        dict(
+            _user_class=user_class,
+            _sig=sig,
+            _positional_args=positional_args,
+            _var_keyword=_get_var_keyword(sig),
+            _pass_children="children" in render_sig.parameters,
+            __module__=user_class.__module__,
+        ),
+    )
+
+
+def _make_func_component(func: Callable) -> Type[_FuncComponent]:
+    orig_sig, positional_args = _make_sig(func)
+    without_children = [
+        param for key, param in orig_sig.parameters.items() if key != "children"
+    ]
+    sig = inspect.Signature(parameters=without_children)
+
+    return type(
+        func.__name__,
+        (_FuncComponent,),
+        dict(
+            _func=func,
+            _sig=sig,
+            _positional_args=positional_args,
+            _var_keyword=_get_var_keyword(orig_sig),
+            _pass_children="children" in orig_sig.parameters,
+            __module__=func.__module__,
+        ),
+    )
+
+
+def _HtmlElem(html_tag: str, parent_class: T) -> T:
+    return type(
+        html_tag.capitalize(),
+        (parent_class,),
+        dict(
+            _html_tag=html_tag,
+            __module__="compone.html",
+        ),
+    )
+
+
+def _Elem(html_tag: str) -> Type[_HTMLComponent]:
+    """Create Component from HTML element on the fly."""
+    return _HtmlElem(html_tag, _HTMLComponent)
+
+
+def _SelfElem(html_tag: str) -> Type[_SelfClosingHTMLComponent]:
+    """Create Component from self-closing HTML element on the fly."""
+    return _HtmlElem(html_tag, _SelfClosingHTMLComponent)

compone-0.1.0/compone/escape.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+from markupsafe import Markup
+from markupsafe import escape as markupsafe_escape
+
+__all__ = ["escape", "safe"]
+
+# Alias, because this is more generic than HTML and make sure
+# that the API is future proof in case we change implementation
+safe = Markup
+"""Exclude a string from autoescaping using Markupsafe."""
+
+
+def escape(s: Any) -> safe:
+    """Replace special characters to HTML/XML-safe sequences.
+    Marks the resulting string as safe with Markupsafe.
+    """
+    if isinstance(s, safe):
+        return s
+    elif s is None:
+        return safe()
+    # We use the __str__ method instead of __html__
+    elif hasattr(s, "__str__"):
+        s = s.__str__()
+
+    return markupsafe_escape(s)

compone-0.1.0/compone/html/__init__.py

@@ -0,0 +1,95 @@
+# ruff: noqa: F401
+from ..component import _Elem
+from .content_sectioning import (
+    H1,
+    H2,
+    H3,
+    H4,
+    H5,
+    H6,
+    Address,
+    Article,
+    Aside,
+    Footer,
+    Header,
+    Main,
+    Nav,
+    Section,
+)
+from .embedded import Embed, Iframe, Object, Picture, Portal, Source
+from .forms import (
+    Button,
+    ButtonButton,
+    Datalist,
+    Fieldset,
+    Form,
+    Input,
+    Label,
+    Legend,
+    Meter,
+    Optgroup,
+    Option,
+    Output,
+    Progress,
+    ResetButton,
+    Select,
+    SubmitButton,
+    Textarea,
+)
+from .inline_text import (
+    A,
+    Abbr,
+    B,
+    Bdi,
+    Bdo,
+    Br,
+    Cite,
+    Code,
+    Data,
+    Del,
+    Dfn,
+    Em,
+    I,
+    Ins,
+    Kbd,
+    Mark,
+    Q,
+    Rp,
+    Rt,
+    Ruby,
+    S,
+    Samp,
+    Small,
+    Span,
+    Strong,
+    Sub,
+    Sup,
+    Time,
+    U,
+    Var,
+    Wbr,
+)
+from .interactive import Details, Dialog, Summary
+from .main import Body, Html
+from .metadata import Base, Head, Link, Meta, Style, Title
+from .multimedia import Area, Audio, Img, Map, Track, Video
+from .other import Math, Svg
+from .scripting import Canvas, Noscript, Script
+from .table import Caption, Col, Colgroup, Table, Tbody, Td, Tfoot, Th, Thead, Tr
+from .text_content import (
+    Blockquote,
+    Dd,
+    Div,
+    Dl,
+    Dt,
+    Figcaption,
+    Figure,
+    Hr,
+    Li,
+    Menu,
+    Ol,
+    P,
+    Pre,
+    Ul,
+)
+from .web_components import Slot, Template

compone-0.1.0/compone/html/content_sectioning.py

@@ -0,0 +1,16 @@
+from ..component import _Elem
+
+Address = _Elem("address")
+Article = _Elem("article")
+Aside = _Elem("aside")
+Footer = _Elem("footer")
+Header = _Elem("header")
+H1 = _Elem("h1")
+H2 = _Elem("h2")
+H3 = _Elem("h3")
+H4 = _Elem("h4")
+H5 = _Elem("h5")
+H6 = _Elem("h6")
+Main = _Elem("main")
+Nav = _Elem("nav")
+Section = _Elem("section")

compone-0.1.0/compone/html/embedded.py

@@ -0,0 +1,8 @@
+from ..component import _Elem, _SelfElem
+
+Embed = _SelfElem("embed")
+Iframe = _Elem("iframe")
+Object = _Elem("object")
+Picture = _Elem("picture")
+Portal = _Elem("portal")
+Source = _SelfElem("source")

compone-0.1.0/compone/html/forms.py

@@ -0,0 +1,31 @@
+from ..component import _Elem, _HTMLComponent, _SelfElem
+
+Datalist = _Elem("datalist")
+Fieldset = _Elem("fieldset")
+Button = _Elem("button")
+Form = _Elem("form")
+Input = _SelfElem("input")
+Label = _Elem("label")
+Legend = _Elem("legend")
+Meter = _Elem("meter")
+Optgroup = _Elem("optgroup")
+Option = _Elem("option")
+Output = _Elem("output")
+Progress = _Elem("progress")
+Select = _Elem("select")
+Textarea = _Elem("textarea")
+
+
+class ButtonButton(_HTMLComponent):
+    _html_tag = "button"
+    _attributes = {"type": "button"}
+
+
+class ResetButton(_HTMLComponent):
+    _html_tag = "button"
+    _attributes = {"type": "reset"}
+
+
+class SubmitButton(_HTMLComponent):
+    _html_tag = "button"
+    _attributes = {"type": "submit"}

compone-0.1.0/compone/html/inline_text.py

@@ -0,0 +1,34 @@
+from ..component import _Elem
+from ..escape import safe
+
+A = _Elem("a")
+Abbr = _Elem("abbr")
+B = _Elem("b")
+Bdi = _Elem("bdi")
+Bdo = _Elem("bdo")
+Br = safe("<br>")
+Cite = _Elem("cite")
+Code = _Elem("code")
+Data = _Elem("data")
+Del = _Elem("del")
+Dfn = _Elem("dfn")
+Em = _Elem("em")
+I = _Elem("i")  # noqa: E741
+Ins = _Elem("ins")
+Kbd = _Elem("kbd")
+Mark = _Elem("mark")
+Q = _Elem("q")
+Rp = _Elem("rp")
+Rt = _Elem("rt")
+Ruby = _Elem("ruby")
+S = _Elem("s")
+Samp = _Elem("samp")
+Small = _Elem("small")
+Span = _Elem("span")
+Strong = _Elem("strong")
+Sub = _Elem("sub")
+Sup = _Elem("sup")
+Time = _Elem("time")
+U = _Elem("u")
+Var = _Elem("var")
+Wbr = safe("<wbr />")

compone-0.1.0/compone/html/interactive.py

@@ -0,0 +1,5 @@
+from ..component import _Elem
+
+Details = _Elem("details")
+Dialog = _Elem("dialog")
+Summary = _Elem("summary")

compone-0.1.0/compone/html/main.py

@@ -0,0 +1,4 @@
+from ..component import _Elem
+
+Html = _Elem("html")
+Body = _Elem("body")

compone-0.1.0/compone/html/metadata.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+from ..component import Component, _Elem, _SelfElem
+from ..escape import safe
+
+Base = _Elem("base")
+Head = _Elem("head")
+Link = _SelfElem("link")
+Style = _Elem("style")
+Title = _Elem("title")
+
+
+@Component
+def Meta(
+    *,
+    name: str,
+    http_equiv: Optional[str] = None,
+    itemprop: Optional[str] = None,
+    content: Optional[str] = None,
+):
+    kwargs = {"name": name}
+    if http_equiv:
+        kwargs["http-equiv"] = http_equiv
+    if content:
+        kwargs["content"] = content
+    if itemprop:
+        kwargs["itemprop"] = itemprop
+
+    return _SelfElem("meta")(**kwargs)
+
+
+@Component
+def MetaCharset():
+    # If the attribute is present, its value must be
+    # an ASCII case-insensitive match for the string "utf-8",
+    # because UTF-8 is the only valid encoding for HTML5 documents.
+    # https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta#charset
+    return safe('<meta charset="utf-8">')

compone-0.1.0/compone/html/multimedia.py

@@ -0,0 +1,8 @@
+from ..component import _Elem, _SelfElem
+
+Area = _SelfElem("area")
+Audio = _Elem("audio")
+Img = _SelfElem("img")
+Map = _Elem("map")
+Track = _SelfElem("track")
+Video = _Elem("video")

compone-0.1.0/compone/html/other.py

@@ -0,0 +1,4 @@
+from ..component import _Elem
+
+Svg = _Elem("svg")
+Math = _Elem("math")

compone-0.1.0/compone/html/scripting.py

@@ -0,0 +1,5 @@
+from ..component import _Elem
+
+Canvas = _Elem("canvas")
+Noscript = _Elem("noscript")
+Script = _Elem("script")

compone-0.1.0/compone/html/table.py

@@ -0,0 +1,12 @@
+from ..component import _Elem
+
+Caption = _Elem("caption")
+Col = _Elem("col")
+Colgroup = _Elem("colgroup")
+Table = _Elem("table")
+Tbody = _Elem("tbody")
+Td = _Elem("td")
+Tfoot = _Elem("tfoot")
+Th = _Elem("th")
+Thead = _Elem("thead")
+Tr = _Elem("tr")

compone-0.1.0/compone/html/text_content.py

@@ -0,0 +1,36 @@
+from ..component import _Elem, _HTMLComponent
+from ..escape import safe
+
+Blockquote = _Elem("blockquote")
+Dd = _Elem("dd")
+Dl = _Elem("dl")
+Dt = _Elem("dt")
+Div = _Elem("div")
+Figcaption = _Elem("figcaption")
+Figure = _Elem("figure")
+Hr = safe("<hr>")
+Menu = _Elem("menu")
+P = _Elem("p")
+Pre = _Elem("pre")
+Li = _Elem("li")
+
+
+class _ListComp(_HTMLComponent):
+    def __getitem__(self, children):
+        if isinstance(children, str):
+            children = (children,)
+
+        error_message = "List element children must be <li>"
+        for child in children:
+            ch = str(child).strip()
+            assert ch.startswith("<li") and ch.endswith("</li>"), error_message
+
+        return super().__getitem__(children)
+
+
+class Ul(_ListComp):
+    _html_tag = "ul"
+
+
+class Ol(_ListComp):
+    _html_tag = "ol"

compone-0.1.0/compone/html/web_components.py

@@ -0,0 +1,4 @@
+from ..component import _Elem
+
+Slot = _Elem("slot")
+Template = _Elem("template")

compone-0.1.0/compone/robots/__init__.py

@@ -0,0 +1,3 @@
+# ruff: noqa: F401
+from .html_meta import MetaTag
+from .robots_txt import Bot, Entry, RobotsTxt

compone-0.1.0/compone/robots/html_meta.py

@@ -0,0 +1,40 @@
+from .. import html
+from ..component import Component
+from ..escape import safe
+
+
+@Component
+def MetaTag(
+    *,
+    index: bool = False,
+    follow: bool = False,
+    archive: bool = True,
+    snippet: bool = True,
+):
+    """HTML meta tag for preventing robots to index a specific site.
+
+    noindex: prevents a page from being indexed
+    nofollow: prevents links from being crawled
+    noarchive: not to store an archived copy of the page
+    nosnippet: not include a snippet from the page along with the page's listing in search results
+
+    See:
+      - https://www.robotstxt.org/meta.html
+      - https://en.wikipedia.org/wiki/Meta_element#The_robots_attribute
+    """  # noqa: E501
+
+    directives = []
+    for directive, novalue in [
+        (index, "noindex"),
+        (follow, "nofollow"),
+        (archive, "noarchive"),
+        (snippet, "nosnippet"),
+    ]:
+        if not directive:
+            directives.append(novalue)
+
+    if not directives:
+        return safe("")
+
+    directives_str = ", ".join(directives)
+    return html.Meta(name="robots", content=directives_str)

compone-0.1.0/compone/robots/robots_txt.py

@@ -0,0 +1,73 @@
+"""
+Generating robots.txt and meta tags for search engine crawlers. See:
+- https://www.robotstxt.org/
+- https://developers.google.com/search/docs/crawling-indexing/robots/intro
+- https://en.wikipedia.org/wiki/Meta_element#The_robots_attribute
+"""
+
+import enum
+from typing import List, Optional
+
+from ..component import Component
+
+
+class Bot(enum.Enum):
+    All = "*"
+    Google = "Googlebot"
+    Bing = "Bingbot"
+    Yahoo = "Slurp"
+    Yandex = "Yandex"
+    Baidu = "BaiduSpider"
+    # https://duckduckgo.com/duckduckgo-help-pages/results/duckduckbot/
+    DuckDuckGo = "DuckDuckBot"
+    # https://developer.twitter.com/en/docs/twitter-for-websites/cards/guides/getting-started
+    Twitter = "Twitterbot"
+
+
+@Component
+def RobotsTxt(*, children: List["Entry"]):
+    return children
+
+
+@Component
+def Entry(
+    *,
+    user_agent: Bot,
+    disallow: List[str],
+    allow: List[str] = [],
+    crawdelay: Optional[int] = None,
+    sitemap: Optional[str] = None,
+):
+    return [
+        UserAgent(agent=user_agent),
+        *[Disallow(path=path) for path in disallow],
+        *[Allow(path=path) for path in allow],
+        CrawDelay(delay=crawdelay) if crawdelay else None,
+        Sitemap(url=sitemap) if sitemap else None,
+        "\n",
+    ]
+
+
+@Component
+def UserAgent(*, agent: Bot):
+    return f"User-agent: {agent.value}\n"
+
+
+@Component
+def Disallow(*, path: str):
+    return f"Disallow: {path}\n"
+
+
+@Component
+def Allow(*, path: str):
+    return f"Allow: {path}\n"
+
+
+@Component
+def CrawDelay(*, delay: int):
+    return f"Crawl-delay: {delay}\n"
+
+
+@Component
+def Sitemap(*, url: str):
+    return f"Sitemap: {url}\n"

compone-0.1.0/compone/utils.py

@@ -0,0 +1,7 @@
+def _is_iterable(content):
+    try:
+        iter(content)
+    except TypeError:
+        return False
+    else:
+        return True

compone-0.1.0/compone/xml.py

@@ -0,0 +1,11 @@
+from .component import _ChildrenBase, _HTMLComponentBase, safe
+
+Xml10 = safe('<?xml version="1.0" encoding="UTF-8"?>')
+Xml11 = safe('<?xml version="1.1" encoding="UTF-8"?>')
+
+
+class Comment(_ChildrenBase, _HTMLComponentBase):
+    def __str__(self) -> str:
+        # Anything inside comments should not be escaped
+        children = "".join(str(e) for e in self._children)
+        return safe(f"<-- {children} -->")

compone-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[tool.poetry]
+name = "compone"
+version = "0.1.0"
+description = "Component framework for Python"
+authors = ["György Kiss <gyorgy@duck.com>"]
+license = "MIT"
+readme = "README.md"
+package-mode = true
+packages = [{ include = "compone" }]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+markupsafe = "^2.1.5"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"