hyperdivlite 0.1.9__py3-none-any.whl

hyperdiv/prop_types/tests/optional_tests.py

@@ -0,0 +1,22 @@
+import pytest
+from ..optional import Optional
+from ..native import Int
+from ..size import BaseSize
+
+
+def test_optional():
+    o = Optional(Int)
+
+    assert repr(o) == "Optional[Int]"
+
+    assert o.parse(None) is None
+    assert o.parse(1) == 1
+
+    with pytest.raises(TypeError):
+        o.parse("Hello")
+
+    o = Optional(BaseSize)
+    assert o.parse(None) is None
+    assert o.render(None) is None
+    assert o.parse("12rem") == BaseSize.parse("12rem")
+    assert o.render(o.parse("12rem")) == BaseSize.render(BaseSize.parse("12rem"))

hyperdiv/prop_types/tests/time_value_tests.py

@@ -0,0 +1,31 @@
+import pytest
+from ..time_value import TimeValue
+
+
+def test_time_value():
+    assert repr(TimeValue) == "TimeValue"
+
+    assert TimeValue.parse("12ms") == (12, "ms")
+    assert TimeValue.parse("+12ms") == (12, "ms")
+    assert TimeValue.parse("-12ms") == (-12, "ms")
+
+    assert TimeValue.parse("12s") == (12, "s")
+    assert TimeValue.parse("+12s") == (12, "s")
+    assert TimeValue.parse("-12s") == (-12, "s")
+
+    assert TimeValue.parse((12, "s")) == (12, "s")
+    assert TimeValue.parse((-12, "s")) == (-12, "s")
+
+    with pytest.raises(ValueError):
+        TimeValue.parse((1, "s", 2))
+
+    with pytest.raises(ValueError):
+        TimeValue.parse((1, "m"))
+
+    with pytest.raises(ValueError):
+        TimeValue.parse(("1", "s"))
+
+    assert TimeValue.render((12, "ms")) == "12ms"
+    assert TimeValue.render((-12, "ms")) == "-12ms"
+    assert TimeValue.render((12, "s")) == "12s"
+    assert TimeValue.render((-12, "s")) == "-12s"

hyperdiv/prop_types/tests/tuple_type_tests.py

@@ -0,0 +1,26 @@
+import pytest
+from ..tuple_type import Tuple
+from ..native import Int, PureString
+
+
+def test_tuple():
+    t = Tuple(Int, PureString)
+
+    assert repr(t) == "Tuple[Int, PureString]"
+
+    assert t.parse((1, "Hello")) == (1, "Hello")
+    assert t.parse((-10, "Hello")) == (-10, "Hello")
+
+    assert t.render((-10, "Hello")) == (-10, "Hello")
+
+    with pytest.raises(TypeError):
+        t.parse((1, 1))
+
+    with pytest.raises(TypeError):
+        t.parse(("Hello", 1))
+
+    with pytest.raises(ValueError):
+        t.parse((1, "Hello", 2))
+
+    with pytest.raises(ValueError):
+        t.parse("Hello")

hyperdiv/prop_types/tests/union_tests.py

@@ -0,0 +1,18 @@
+import pytest
+from ..union import Union
+from ..native import Int, PureString
+
+
+def test_union():
+    u = Union(Int, PureString)
+
+    assert repr(u) == "Union[Int, PureString]"
+
+    assert u.parse(1) == 1
+    assert u.parse("Hello") == "Hello"
+
+    with pytest.raises(TypeError):
+        u.parse(dict())
+
+    with pytest.raises(TypeError):
+        u.parse(b"123")

hyperdiv/prop_types/time_value.py

@@ -0,0 +1,55 @@
+from .hyperdiv_type import HyperdivType
+
+
+class TimeValueDef(HyperdivType):
+    """
+    A type that supports time values. See
+    [here](https://developer.mozilla.org/en-US/docs/Web/CSS/time).
+
+    It accepts a numeric value followed by a unit, where the unit has
+    to be one of `"s"` (seconds) or `"ms"` (milliseconds).
+
+    The value shape can be either a string, like `"12ms"`, or a tuple
+    like `(12, "ms")`.
+
+    Examples:
+
+    ```py
+    "12ms"
+    "+12.5ms"
+    "-1.6s"
+    (12, "ms")
+    (12.5, "ms")
+    (-1.6, "s")
+    ```
+    """
+
+    def parse(self, value):
+        if isinstance(value, (tuple, list)):
+            if len(value) != 2:
+                raise ValueError(f"Expected a tuple of length 2 but got {value}")
+            scalar, unit = value
+            unit = unit.lower()
+            if unit not in ("s", "ms"):
+                raise ValueError(f"Unknown unit for TimeValue: {unit}")
+            if not isinstance(scalar, (int, float)):
+                raise ValueError(f"Expected an int or float but got {scalar}")
+        else:
+            value = value.lower()
+            if value.endswith("ms"):
+                unit = "ms"
+                scalar = value[:-2]
+            elif value.endswith("s"):
+                unit = "s"
+                scalar = value[:-1]
+        return (float(scalar), unit)
+
+    def render(self, value):
+        scalar, unit = value
+        return f"{scalar}{unit}"
+
+    def __repr__(self):
+        return "TimeValue"
+
+
+TimeValue = TimeValueDef()

hyperdiv/prop_types/tuple_type.py

@@ -0,0 +1,43 @@
+from .hyperdiv_type import HyperdivType
+
+
+class Tuple(HyperdivType):
+    """
+    `Tuple(type1, type2, ... typeN)` creates a Hyperdiv type that
+    accepts Python tuples of the shape `(value1, value2, ... valueN)`
+    such that `value1` has Hyperdiv type `type1`, `value2` has
+    Hyperdiv type `type2`, and so on.
+
+    For example `hd.Tuple(hd.Int, hd.PureString)` will accept values
+    like `(1, "Hello")`, `(50, "Bunnies")`, etc.
+
+    The internally stored value is a tuple of values parsed by their
+    respective types.
+    """
+
+    def __init__(self, *types):
+        self.types = types
+
+    def parse(self, value):
+        if not isinstance(value, (tuple, list)):
+            raise ValueError(f"Expected a tuple or list but got {type(value)}")
+
+        if len(value) != len(self.types):
+            raise ValueError(
+                f"Tuple should have length {len(self.types)} but got {len(value)}"
+            )
+
+        output = []
+        for i, component in enumerate(value):
+            output.append(self.types[i].parse(component))
+        return tuple(output)
+
+    def render(self, value):
+        output = []
+        for i, component in enumerate(value):
+            output.append(self.types[i].render(component))
+        return tuple(output)
+
+    def __repr__(self):
+        args_str = ", ".join(repr(t) for t in self.types)
+        return f"Tuple[{args_str}]"

hyperdiv/prop_types/union.py

@@ -0,0 +1,28 @@
+from .hyperdiv_type import HyperdivType
+
+
+class Union(HyperdivType):
+    """
+    `Union(typ1, typ2)` creates a type that accepts values of either
+    `typ1` or `typ2`. It tries to parse the value with `typ1` first,
+    and if that fails, it tries `typ2`.
+    """
+
+    def __init__(self, typ1, typ2):
+        self.typ1 = typ1
+        self.typ2 = typ2
+
+    def parse(self, value):
+        try:
+            return self.typ1.parse(value)
+        except Exception:
+            return self.typ2.parse(value)
+
+    def render(self, value):
+        try:
+            return self.typ1.render(value)
+        except Exception:
+            return self.typ2.render(value)
+
+    def __repr__(self):
+        return f"Union[{repr(self.typ1)}, {repr(self.typ2)}]"

hyperdiv/renderer.py

@@ -0,0 +1,260 @@
+from jinja2 import Template
+import json
+from .prop_types import Bool
+
+selector_template = "{selector}"
+
+
+def render_css_props(css_props):
+    # Format string allowing the caller to replace '{selector}' with
+    # the real selector.
+    selector = selector_template
+    active_selector = f"{selector}:active"
+    hover_selector = f"{selector}:hover"
+
+    style = {
+        selector: dict(),
+        active_selector: dict(),
+        hover_selector: dict(),
+    }
+
+    for prop in css_props:
+        css = prop.render()
+        if css:
+            if prop.name == "hover_background_color":
+                style[hover_selector].update(css)
+            elif prop.name == "active_background_color":
+                style[active_selector].update(css)
+            else:
+                style[selector].update(css)
+
+    return style
+
+
+def flatten_style(style):
+    output = dict()
+    for selector, css in style.items():
+        if not css:
+            continue
+        output[selector] = ";".join([f"{k}:{v}" for k, v in css.items()])
+    return output
+
+
+def render_css(key, css_props):
+    # TODO: fix circular import
+    from .style_part import StylePart
+
+    if not css_props:
+        return None
+
+    root_props = []
+    css_parts = []
+    base_part = None
+
+    for prop in css_props:
+        if isinstance(prop.prop_type, StylePart):
+            if prop.prop_type.is_base_part:
+                base_part = prop
+            css_parts.append(prop)
+        else:
+            root_props.append(prop)
+
+    root_selector = f"#{key}"
+
+    # Render the root style
+    style = {
+        css_key.format(selector=root_selector): css_value
+        for css_key, css_value in render_css_props(root_props).items()
+    }
+
+    # Render the part styles
+    for css_part in css_parts:
+        rendered_part = css_part.render()
+        if rendered_part:
+            part_selector = f"{root_selector}::part({css_part.prop_type.part_name})"
+            part_style = {
+                css_key.format(selector=part_selector): css_value
+                for css_key, css_value in rendered_part.items()
+            }
+            style.update(part_style)
+
+    root_style = style.get(root_selector)
+
+    if base_part and root_style:
+        # If the component has a base part, we move the root styles to
+        # the base selector. If the component has a root selector (the
+        # vast majority of components do), we leave dimension and flex
+        # attributes on the root.
+        base_selector = f"{root_selector}::part({base_part.prop_type.part_name})"
+
+        style.setdefault(base_selector, dict())
+
+        for attr_name, attr_value in dict(root_style).items():
+            if base_part.prop_type.has_root:
+                if attr_name in ("width", "height", "max-width", "max-height"):
+                    if attr_name not in style[base_selector]:
+                        style[base_selector][attr_name] = "100%"
+                    continue
+                if attr_name in ("flex-basis", "flex-grow", "flex-shrink"):
+                    continue
+            # If the attribute is not set in the base selector, we
+            # move it from the root to the base.
+            if attr_name not in style[base_selector]:
+                style[base_selector][attr_name] = attr_value
+                root_style.pop(attr_name)
+
+    return flatten_style(style)
+
+
+def render_slot_name(name):
+    return name.replace("_", "-")
+
+
+def render_props(key, props):
+    css_props, normal_props = [], []
+
+    for prop in props:
+        if prop.name == "slot" and prop.value is None:
+            continue
+        if prop.is_css_prop:
+            css_props.append(prop)
+        elif not prop.internal:
+            normal_props.append(prop)
+
+    output = dict(props={prop.ui_name: prop.render() for prop in normal_props})
+
+    style = render_css(key, css_props)
+    if style is not None:
+        output["style"] = style
+
+    return output
+
+
+def render_component(component):
+    key = component._key
+    name = component._name
+    tag = component._tag
+    classes = component._classes
+    props = component._get_stored_props().values()
+
+    output = dict(key=key, name=name, tag=tag, classes=classes) | render_props(
+        key, props
+    )
+
+    if component._has_children:
+        output["children"] = [child.render() for child in component._children]
+
+    return output
+
+
+# Experimental HTML Renderer -- Currently Unused.
+
+
+def render_value(value):
+    import json
+
+    return json.dumps(value)
+
+
+def render_prop_to_html(prop):
+    value = prop.render()
+    if isinstance(value, (list, tuple)):
+        value = " ".join(value)
+    return value
+
+
+def render_component_to_html(component, indent=0):
+    key = component._key
+    name = component._name
+    tag = component._tag
+    classes = component._classes
+    props = component._get_stored_props()
+
+    if name == "plaintext":
+        return (" " * indent) + component.content, {}
+
+    css_props, normal_props = [], []
+
+    for prop in props.values():
+        if prop.name == "slot" and prop.value is None:
+            continue
+        if prop.is_css_prop:
+            css_props.append(prop)
+        elif not prop.is_event_prop:
+            normal_props.append(prop)
+
+    css = render_css(key, css_props) or dict()
+
+    rendered_props = []
+
+    for prop in normal_props:
+        if prop.value == prop.default_value:
+            continue
+
+        if name in ("markdown", "text") and prop.name == "content":
+            continue
+
+        if prop.prop_type == Bool and prop.value:
+            rendered_props.append(f"{prop.ui_name}")
+            continue
+
+        rendered_props.append(f"{prop.ui_name}={json.dumps(render_prop_to_html(prop))}")
+
+    opening_tag = f'<{tag} id="{key}"'
+
+    if len(classes) > 0:
+        opening_tag += f" class=\"{' '.join(classes)}\""
+
+    if len(rendered_props) > 0:
+        opening_tag += " " + " ".join(rendered_props) + ">"
+    else:
+        opening_tag += ">"
+
+    closing_tag = f"</{tag}>"
+
+    output = (" " * indent) + opening_tag
+
+    if name == "text":
+        content = props.get("content")
+        output += content.render() + closing_tag
+    elif name == "markdown":
+        content = props.get("content")
+        if content.value:
+            output += content.render()
+        output += closing_tag
+    elif (
+        component._has_children
+        and len(component._children) == 1
+        and component._children[0]._name == "plaintext"
+    ):
+        child_html, child_css = render_component_to_html(component._children[0])
+        output += child_html.strip() + closing_tag
+        css |= child_css
+    elif component._has_children and len(component._children) > 0:
+        output += "\n"
+        for child in component._children:
+            child_html, child_css = render_component_to_html(child, indent=(indent + 1))
+            output += child_html
+            output += "\n"
+            css |= child_css
+        output += (" " * indent) + closing_tag
+    else:
+        output += closing_tag
+
+    return output, css
+
+
+def flatten_css(css):
+    output = ""
+
+    for selector, rules in css.items():
+        if not rules:
+            continue
+        output += selector + " { " + rules + " }\n"
+
+    return output
+
+
+def render_into_template(html, css, template_text):
+    template = Template(template_text)
+    return template.render(body=html, style=flatten_css(css))

hyperdiv/server.py

@@ -0,0 +1,163 @@
+import datetime
+import os
+import sys
+import signal
+from tornado.web import Application, StaticFileHandler, HTTPError
+from tornado.httpserver import HTTPServer
+from tornado.ioloop import IOLoop
+from .debug import logger, PRODUCTION
+from .connection import Connection
+from .plugin import PluginAssetsCollector, PLUGINS_PREFIX
+from .frontend import get_frontend_public_path
+
+
+class Server:
+    _instance = None
+
+    def __init__(self, port, app_function, task_runtime, index_page):
+        if Server._instance:
+            raise Exception("Hyperdiv is already running.")
+        Server._instance = self
+        self.port = port
+        self.app_function = app_function
+        self.task_runtime = task_runtime
+        self.ioloop = IOLoop.current()
+        self.app = self.create_application(index_page)
+        self.server = HTTPServer(self.app)
+        self.stopping = False
+
+    def listen(self):
+        self.server.listen(self.port, address=os.environ.get("HD_HOST", "localhost"))
+
+    def start(self):
+        print(
+            f"Running at http://{os.environ.get('HD_HOST', 'localhost')}:{self.port}",
+            file=sys.stderr,
+        )
+        print("Ctrl-C to exit", file=sys.stderr)
+
+        signal.signal(signal.SIGINT, self.stop)
+        signal.signal(signal.SIGTERM, self.stop)
+
+        try:
+            self.ioloop.start()
+        except Exception:
+            logger.exception("Ioloop exited abnormally.")
+
+    def stop(self, sig, frame):
+        # In case termination signal is sent repeatedly while the
+        # server is shutting down, avoid enqueueing the draining
+        # callbacks multiple times.
+        if self.stopping:
+            return
+        self.stopping = True
+
+        logger.info(f"Stopping with signal {sig}.")
+        # Stop the server from accepting new connections:
+        self.ioloop.add_callback_from_signal(self.server.stop)
+        # Close all connections
+        self.ioloop.add_callback_from_signal(Connection.close_all_connections)
+        # Stop the ioloop, which will cause `self.run()` to return:
+        self.ioloop.add_callback_from_signal(self.ioloop.stop)
+
+    def create_application(self, index_page):
+        index_bytes = index_page.encode("utf-8")
+        modified_time = datetime.datetime.now()
+
+        class HyperdivStaticFileHandler(StaticFileHandler):
+            """
+            When the UI requests a file that does not exist, this static file
+            handler returns the index contents. This allows the app to
+            load from any valid Hyperdiv location path, even though
+            that path doesn't exist on the filesystem.
+            """
+
+            @classmethod
+            def get_absolute_path(cls, root, path):
+                if not path:
+                    return "<index>"
+                try:
+                    os.stat(os.path.join(root, path))
+                    return super().get_absolute_path(root, path)
+                except FileNotFoundError:
+                    return "<index>"
+
+            def validate_absolute_path(self, root, abspath):
+                if abspath == "<index>":
+                    return "<index>"
+                return super().validate_absolute_path(root, abspath)
+
+            @classmethod
+            def get_content(cls, abspath, start=None, end=None):
+                if abspath == "<index>":
+                    return index_bytes
+                return super().get_content(abspath, start=start, end=end)
+
+            def get_modified_time(self):
+                if self.absolute_path == "<index>":
+                    return modified_time
+                return super().get_modified_time()
+
+            def get_content_size(self):
+                if self.absolute_path == "<index>":
+                    return len(index_bytes)
+                return super().get_content_size()
+
+            def get_content_type(self):
+                if self.absolute_path == "<index>":
+                    return "text/html"
+                return super().get_content_type()
+
+        class HyperdivPluginHandler(StaticFileHandler):
+            @classmethod
+            def get_absolute_path(cls, root, path):
+                # We are expecting paths like `<plugin_name>/<asset_path>`.
+                split_path = path.split("/", 1)
+                if len(split_path) == 2:
+                    plugin_name = split_path[0]
+                    assets_config = PluginAssetsCollector.plugin_assets.get(plugin_name)
+                    if assets_config:
+                        root = assets_config["assets_root"]
+                        path = split_path[1]
+                        return super().get_absolute_path(root, path)
+                raise HTTPError(404)
+
+        public_path = get_frontend_public_path()
+
+        routes = []
+
+        routes.append(
+            (rf"{PLUGINS_PREFIX}/(.*)", HyperdivPluginHandler, dict(path="/"))
+        )
+
+        assets_dir = os.path.join(
+            os.path.dirname(os.path.abspath(sys.argv[0])), "assets"
+        )
+        if os.path.isdir(assets_dir):
+            routes.append(
+                (
+                    r"/assets/(.*)",
+                    StaticFileHandler,
+                    dict(path=assets_dir),
+                )
+            )
+
+        routes.extend(
+            [
+                (
+                    r"/ws",
+                    Connection,
+                    dict(
+                        app_function=self.app_function,
+                        task_runtime=self.task_runtime,
+                        ioloop=self.ioloop,
+                    ),
+                ),
+                (
+                    r"/(.*)",
+                    HyperdivStaticFileHandler,
+                    dict(path=public_path),
+                ),
+            ]
+        )
+        return Application(routes, debug=not PRODUCTION)

hyperdiv/slot.py

@@ -0,0 +1,35 @@
+class Slot:
+    def __init__(self, ui_name=None):
+        self.name = None
+        self.ui_name = ui_name.replace("_", "-") if ui_name else ui_name
+
+    def __set_name__(self, klass, name):
+        self.name = name
+        if not self.ui_name:
+            self.ui_name = self.name.replace("_", "-")
+
+    def __get__(self, component, objtype):
+        return self
+
+    def __set__(self, component, value):
+        raise Exception("Slots are read-only.")
+
+    def __hash__(self):
+        return hash(self.name)
+
+    def __repr__(self):
+        return f"<Slot {self.name}>"
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, Slot)
+            and self.name == other.name
+            and self.ui_name == other.ui_name
+        )
+
+    def __neq__(self, other):
+        return (
+            not isinstance(other, Slot)
+            or self.name != other.name
+            or self.ui_name != other.ui_name
+        )