hyperdivlite 0.1.9__py3-none-any.whl

hyperdiv/sqlite.py

@@ -0,0 +1,127 @@
+import sqlite3
+from functools import wraps
+
+
+def dict_factory(cursor, row):
+    """Row factory that returns dicts mapping column name to column value,
+    as opposed to the default factory, which returns tuples.
+    """
+    d = {}
+    for idx, col in enumerate(cursor.description):
+        d[col[0]] = row[idx]
+    return d
+
+
+class sqlite(object):
+    """Non-transaction/autocommit context. Use:
+
+    with sqlite(db_path) as (_, cursor):
+        cursor.execute('select foo from bar')
+        rows = cursor.fetchall()
+        ...
+
+    """
+
+    def __init__(self, db, timeout=0.4):
+        self.db = db
+        self.timeout = timeout
+        self.conn = None
+        self.cursor = None
+
+    def __enter__(self):
+        self.conn = sqlite3.connect(self.db, timeout=self.timeout)
+        self.conn.row_factory = dict_factory
+        self.conn.isolation_level = None
+        self.cursor = self.conn.cursor()
+        return self.conn, self.cursor
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        self.cursor.close()
+        self.conn.close()
+
+
+class sqlite_tx(sqlite):
+    """Transactional context. Use:
+
+    with sqlite_tx(db_path) as (_, cursor):
+        cursor.execute('select foo from bar')
+        rows = cursor.fetchall()
+        ...
+
+    The body of the `with` block is executed inside a sqlite
+    transaction. If an exception is raised in the body, the
+    transaction is rolled back.
+    """
+
+    def __enter__(self):
+        conn, cursor = super().__enter__()
+        cursor.execute("begin exclusive transaction")
+        return conn, cursor
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        if exc_type is None:
+            self.cursor.execute("commit")
+        else:
+            self.cursor.execute("rollback")
+        super().__exit__(exc_type, exc_value, exc_tb)
+
+
+def retry(fn):
+    # These errors can happen randomly due to contention and it's safe
+    # to retry when they happen.
+    errors = ("database is locked", "disk I/O error")
+
+    @wraps(fn)
+    def fn_wrapper(*args, **kwargs):
+        while True:
+            try:
+                return fn(*args, **kwargs)
+            except sqlite3.OperationalError as e:
+                if str(e) not in errors:
+                    raise
+
+    return fn_wrapper
+
+
+def migrate(db_path, migrations):
+    """A migration is a function that takes a cursor and uses it to modify
+    the db in some way. `migrations` is a list of such functions.
+    """
+    with sqlite_tx(db_path) as (_, cursor):
+        # If the _Migration table doesn't exist, create it.
+        try:
+            cursor.execute("select * from _Migration")
+            table_exists = True
+        except sqlite3.OperationalError as e:
+            if "no such table" in str(e):
+                table_exists = False
+            else:
+                raise
+
+        if not table_exists:
+            cursor.execute("create table _Migration (migration_id integer not null)")
+            cursor.execute("insert into _Migration (migration_id) values (?)", (0,))
+
+        # The migration_id indicates the number/position in the
+        # migrations list of the most recent migration applied. We
+        # apply the rest of the migrations in the list, if any.
+
+        cursor.execute("select migration_id from _Migration")
+        rows = cursor.fetchall()
+        migration_id = rows[0]["migration_id"]
+
+        if len(migrations) < migration_id:
+            raise Exception("The migration list got smaller.")
+
+        migrations_to_apply = migrations[migration_id:]
+        print(f"Applying {len(migrations_to_apply)} migrations.")
+        for migration in migrations_to_apply:
+            migration(cursor)
+            cursor.execute("update _Migration set migration_id = migration_id + 1")
+
+
+def sql(sql_text):
+    """This function can be used as the most basic way to define a migration. E.g.,
+    migration = sql("drop table Foo")
+    """
+    return lambda cursor: cursor.execute(sql_text)

hyperdiv/style_part.py

@@ -0,0 +1,47 @@
+from .prop_types import CSS
+from .components.style import style, boxy_props
+from .renderer import render_css_props, selector_template
+
+
+class StylePart(CSS):
+    """
+    The type of a style part.
+
+    The values accepted by this type are `hyperdiv.style()` objects.
+    """
+
+    def __init__(self, part_name, /, is_base_part=False, has_root=True):
+        self.part_name = part_name
+        self.is_base_part = is_base_part
+        self.has_root = has_root
+
+    def parse(self, value):
+        if value is None:
+            return None
+        if not isinstance(value, style):
+            raise ValueError(f"Expected type `style` but got {type(style)}")
+        return value
+
+    def render(self, style_part):
+        if style_part is None:
+            return None
+
+        props = style_part._get_stored_props()
+        rendered = render_css_props(props.values())
+
+        for boxy_prop in boxy_props:
+            if props[boxy_prop].value is not None:
+                # If a boxy prop is set to a concrete value, we tack
+                # "display:flex" onto the output CSS, because boxy props
+                # don't make sense in non-flex context.
+                rendered[selector_template] |= dict(display="flex")
+                break
+
+        return rendered
+
+    def __repr__(self):
+        return f"StylePart[{self.part_name}]"
+
+
+def BasePart(part_name="base", has_root=True):
+    return StylePart(part_name, is_base_part=True, has_root=has_root)

hyperdiv/task_runtime.py

@@ -0,0 +1,54 @@
+from concurrent.futures import ThreadPoolExecutor
+import asyncio
+import threading
+
+
+class TaskRuntime:
+    def __init__(self, pool_max_workers, executor=None):
+        self.threadpool = executor or ThreadPoolExecutor(max_workers=pool_max_workers)
+        self.ioloop = asyncio.new_event_loop()
+        self.thread_futures = []  # Store futures for threadpool tasks
+
+        self.ioloop_thread = threading.Thread(target=self._start_ioloop)
+        self.ioloop_thread.start()
+
+    def _start_ioloop(self):
+        asyncio.set_event_loop(self.ioloop)
+        self.ioloop.run_forever()
+
+    def run_on_ioloop(self, coro):
+        asyncio.run_coroutine_threadsafe(coro, self.ioloop)
+
+    def run_in_threadpool(self, fn):
+        future = self.threadpool.submit(fn)
+        self.thread_futures.append(future)
+        self._cleanup_thread_futures()
+        return future
+
+    def _cleanup_thread_futures(self):
+        # Remove completed futures
+        self.thread_futures = [f for f in self.thread_futures if not f.done()]
+
+    def is_empty(self):
+        self._cleanup_thread_futures()
+
+        # Check if all threadpool futures are done
+        if self.thread_futures:
+            return False
+
+        async def check_ioloop_tasks():
+            current_task = asyncio.current_task(self.ioloop)
+            return not any(
+                t != current_task and not t.done()
+                for t in asyncio.all_tasks(self.ioloop)
+            )
+
+        # Run the check as a coroutine on the event loop
+        loop_check_future = asyncio.run_coroutine_threadsafe(
+            check_ioloop_tasks(), self.ioloop
+        )
+        return loop_check_future.result()
+
+    def shutdown(self):
+        self.threadpool.shutdown()
+        self.ioloop.call_soon_threadsafe(self.ioloop.stop)

hyperdiv/test_utils.py

@@ -0,0 +1,134 @@
+import threading
+from functools import wraps
+from .app_runner import AppRunner
+from .task_runtime import TaskRuntime
+from .frame import Frame
+
+
+class MockFrame(Frame):
+    def get_state(self, key, prop_name):
+        return self._app_runner.state._get(key, prop_name)
+
+    def update_state(self, key, prop_name, value):
+        return self._app_runner.state._update(key, prop_name, value)
+
+
+class MockTaskRuntime:
+    def __init__(self):
+        self.ioloop_fns = []
+        self.threadpool_fns = []
+
+    def run_on_ioloop(self, fn):
+        self.ioloop_fns.append(fn)
+
+    def run_in_threadpool(self, fn):
+        self.threadpool_fns.append(fn)
+
+
+class MockConnection:
+    def __init__(self):
+        self.msgs = []
+        self.has_message = threading.Event()
+
+    def send(self, msg):
+        self.msgs.append(msg)
+        self.has_message.set()
+
+
+mock_initial_updates = [
+    ("location", "path", "/"),
+    ("location", "query_args", ""),
+    ("location", "hash_arg", ""),
+    ("theme", "mode", "dark"),
+    ("theme", "system_mode", "dark"),
+    ("window", "width", 840),
+    ("window", "height", 998),
+]
+
+
+class MockRunner:
+    """
+    This mock runner starts the AppRunner thread.
+
+    When you call `process_updates()`, the updates are enqueued, which
+    triggers the thread to start processing them. The call blocks
+    until the updates are fully processed.
+    """
+
+    def __init__(self, fn, initial_updates=None):
+        self.initial_updates = initial_updates or mock_initial_updates
+        self.fn = fn
+        self.app_runner = None
+        self.task_runtime = None
+        self.connection = None
+
+    def __enter__(self):
+        self.connection = MockConnection()
+        self.task_runtime = TaskRuntime(10)
+        self.app_runner = AppRunner(
+            self.connection, self.task_runtime, self.fn, self.initial_updates
+        )
+        self.app_runner.start()
+        self.app_runner._internal_sync()
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        self.app_runner.stop()
+        self.app_runner.wait()
+        self.task_runtime.shutdown()
+
+    def process_updates(self, updates):
+        self.app_runner.enqueue_ui_updates(updates)
+        self.app_runner._internal_sync()
+
+    def get_state(self, key, prop_name):
+        with MockFrame(self.app_runner) as frame:
+            return frame.get_state(key, prop_name)
+
+
+class MockManualRunner:
+    """
+    This mock runner does not start the AppRunner thread. You can call
+    advance() to manually do one run a time. The run runs
+    synchronously on the caller thread.
+    """
+
+    def __init__(self, fn=None, initial_updates=None):
+        self.task_runtime = MockTaskRuntime()
+        self.connection = MockConnection()
+        self.app_runner = AppRunner(
+            self.connection,
+            self.task_runtime,
+            fn or (lambda: None),
+            initial_updates if initial_updates is not None else mock_initial_updates,
+        )
+        self.app_runner.enqueue_ui_updates(self.app_runner.initial_ui_updates)
+
+    def process_updates(self, updates):
+        self.app_runner.enqueue_ui_updates(updates)
+        self.advance()
+
+    def process_task_mutations(self, mutations):
+        self.app_runner.enqueue_task_mutations(mutations)
+        self.advance()
+
+    def update_state(self, key, prop_name, value):
+        with MockFrame(self.app_runner) as frame:
+            frame.update_state(key, prop_name, value)
+
+    def get_state(self, key, prop_name):
+        with MockFrame(self.app_runner) as frame:
+            return frame.get_state(key, prop_name)
+
+    def advance(self):
+        self.app_runner.stop()
+        self.app_runner.run_loop()
+
+
+def mock_frame(fn):
+    @wraps(fn)
+    def wrapper():
+        mr = MockManualRunner(fn)
+        mr.advance()
+
+    return wrapper

hyperdiv/tests/app_runner_tests.py

@@ -0,0 +1,266 @@
+import pytest
+from ..test_utils import MockRunner, MockManualRunner
+from ..components.lifecycle import lifecycle
+from ..components.plaintext import plaintext
+from ..components.local_storage import local_storage
+from ..components.state import state
+from ..components.button import button
+from ..exceptions import Stop
+
+
+def test_queues():
+    mr = MockManualRunner()
+    mr.advance()
+
+    mr.app_runner.enqueue_ui_updates([("a", "b", "c")])
+    stop, ui_updates, task_mutations = mr.app_runner.process_queue()
+
+    assert ui_updates == [("a", "b", "c")]
+    assert task_mutations == []
+    assert stop is False
+
+    mr.app_runner.enqueue_task_mutations([("a", "b", "c")])
+    stop, ui_updates, task_mutations = mr.app_runner.process_queue()
+
+    assert ui_updates == []
+    assert task_mutations == [("a", "b", "c")]
+    assert stop is False
+
+    mr.app_runner.stop()
+    stop, ui_updates, task_mutations = mr.app_runner.process_queue()
+
+    assert stop is True
+    assert ui_updates == [(lifecycle._key, "app_stopped", True)]
+    assert task_mutations == []
+
+    mr.app_runner.input_queue.put(("bad_key", []))
+
+    with pytest.raises(Exception):
+        mr.app_runner.process_queue()
+
+    stop, ui_updates, task_mutations = mr.app_runner.process_queue()
+    assert stop is False
+    assert ui_updates == task_mutations == []
+
+
+def test_storage():
+    mr = MockManualRunner()
+    ar = mr.app_runner
+
+    storage = ar.get_storage("my_storage")
+    storage["foo"] = "bar"
+
+    assert ar.get_storage("my_storage") == {"foo": "bar"}
+
+
+def test_prop_reset():
+    key = None
+
+    def my_app():
+        nonlocal key
+        t = plaintext(content="Initial")
+        # Save the component key
+        key = t._key
+        t.content = "Updated"
+
+    mr = MockManualRunner(my_app)
+    mr.advance()
+
+    assert mr.get_state(key, "content") == "Updated"
+    mr.process_updates([(key, "content", "$reset")])
+
+    assert mr.get_state(key, "content") == "Initial"
+
+
+def test_commands():
+    def my_app():
+        local_storage.get_item("hello")
+
+    mr = MockManualRunner(my_app)
+    mr.advance()
+
+    conn = mr.connection
+
+    msg = conn.msgs[-1]
+
+    assert "commands" in msg
+    assert len(msg["commands"]) == 1
+    cmd = msg["commands"][0]
+    assert cmd["target"] == "localStorage"
+    assert cmd["command"] == "getItem"
+    assert cmd["args"] == ["hello"]
+
+
+def test_run_loop():
+    # Save component keys in these variables
+    state_key = None
+    button_key = None
+    text_key = None
+
+    def my_app():
+        nonlocal button_key, state_key, text_key
+
+        s = state(count=0)
+        state_key = s._key
+
+        b = button("Click Me")
+        button_key = b._key
+
+        if b.clicked:
+            s.count += 1
+
+        t = plaintext(s.count)
+        text_key = t._key
+
+    with MockRunner(my_app) as mr:
+        # Simulate click
+        mr.process_updates([(button_key, "clicked", True)])
+
+        assert mr.get_state(state_key, "count") == 1
+
+    # A diff was generated with the updated plaintext label
+    conn = mr.connection
+    msg = conn.msgs[-1]
+
+    assert "diff" in msg
+    assert text_key in msg["diff"]
+    assert msg["diff"][text_key]["props"] == {"content": "1"}
+
+
+def test_run_limit():
+    def my_app():
+        s = state(count=0)
+        s.count += 1
+
+    mr = MockManualRunner(my_app)
+    with pytest.raises(RuntimeError):
+        mr.app_runner.run_loop()
+
+
+def test_task_mutations():
+    state_key, text_key = None, None
+
+    def my_app():
+        nonlocal state_key, text_key
+
+        s = state(count=0)
+        state_key = s._key
+
+        if s.count >= 1:
+            t = plaintext("Hello")
+            text_key = t._key
+
+    mr = MockManualRunner(my_app)
+    mr.advance()
+    mr.update_state(state_key, "count", 1)
+    mr.process_task_mutations([(state_key, "count")])
+    assert mr.get_state(state_key, "count") == 1
+
+    conn = mr.connection
+    msg = conn.msgs[-1]
+
+    assert "diff" in msg
+    assert len(msg["diff"]) == 1
+    root = list(msg["diff"].values())[0]
+    assert "children" in root
+    assert len(root["children"]) == 1
+    cmd = root["children"][0]
+    assert len(cmd) == 3
+    assert cmd[0] == "insert"
+    assert cmd[1] == 0
+    assert len(cmd[2]) == 1
+    inserted = cmd[2][0]
+    assert inserted["key"] == text_key
+    assert inserted["props"] == {"content": "Hello"}
+
+
+def test_stop():
+    def my_app():
+        s = state(count=0)
+        s.count += 1
+        raise Stop()
+
+    mr = MockManualRunner(my_app)
+    # If stop() wasn't handled correctly, this would loop
+    # indefinitely.
+    mr.app_runner.run_loop_wrapper()
+
+
+def test_trigger_event():
+    b2_key = None
+    text_key = None
+
+    def my_app():
+        nonlocal b2_key, text_key
+
+        s = state(count=0)
+        b1 = button("Button 1")
+        b2 = button("Button 2")
+        b2_key = b2._key
+
+        if b1.clicked:
+            s.count += 1
+        if b2.clicked:
+            # Trigger a click on b1, which will cause the count to be
+            # incremented in the next frame.
+            b1.trigger_event("clicked", True)
+
+            # While we're here: can't trigger event on a non-event
+            # prop:
+            with pytest.raises(Exception):
+                b1.trigger_event("size", "small")
+
+        t = plaintext(s.count)
+        text_key = t._key
+
+    with MockRunner(my_app) as mr:
+        mr.process_updates([(b2_key, "clicked", True)])
+
+    # Assert that the click on b1 was processed, causing a diff output
+    # with an updated text label.
+    msg = mr.connection.msgs[-1]
+    assert "diff" in msg
+    assert text_key in msg["diff"]
+    assert msg["diff"][text_key]["props"] == {"content": "1"}
+
+
+def test_cannot_mutate_event_props():
+    def my_app():
+        b = button("Click Me")
+        with pytest.raises(Exception):
+            b.clicked = True
+
+    mr = MockManualRunner(my_app)
+    mr.advance()
+
+
+def test_click_twice():
+    """
+    Test that an update batch containing updates to the same prop
+    schedules those updates in different frames.
+    """
+    button_key = None
+    text_key = None
+
+    def my_app():
+        nonlocal button_key, text_key
+
+        s = state(count=0)
+
+        b = button("Click Me")
+        button_key = b._key
+
+        if b.clicked:
+            s.count += 1
+
+        t = plaintext(s.count)
+        text_key = t._key
+
+    with MockRunner(my_app) as mr:
+        mr.process_updates(
+            [
+                (button_key, "clicked", True),
+                (button_key, "clicked", True),
+            ]
+        )
+        assert mr.get_state(text_key, "content") == "2"

hyperdiv/tests/application_state_tests.py

@@ -0,0 +1,67 @@
+import pytest
+from ..test_utils import MockManualRunner
+from ..frame import UIUpdatesFrame, ResetUIEventsFrame, AppRunnerFrame
+from ..component_base import Component
+from ..prop import Prop
+from ..prop_types import Int, Bool, Event
+
+
+class MyComponent(Component):
+    x = Prop(Int, 0)
+    z = Prop(Event(Bool), False)
+
+
+def test_application_state():
+    props = MyComponent._get_static_props()
+    props_with_values = {(prop, prop.default_value) for prop in props}
+
+    mr = MockManualRunner()
+
+    state = mr.app_runner.state
+
+    with AppRunnerFrame(mr.app_runner) as frame:
+        state.init_props("my-key", props_with_values)
+
+        assert frame.get_state("my-key", "x") == 0
+        assert frame.get_state("my-key", "z") is False
+
+        # Reads got registered:
+        assert ("my-key", "x") in frame.deps
+        assert ("my-key", "z") in frame.deps
+
+        frame.update_state("my-key", "x", 20)
+
+        # The update/mutation got registered:
+        assert ("my-key", "x") in frame.mutations
+
+        assert frame.get_state("my-key", "x") == 20
+
+        # Reset to default value
+        frame.reset_state("my-key", "x")
+        assert frame.get_state("my-key", "x") == 0
+
+        assert state.has_prop("my-key", "x")
+        assert state.has_prop("my-key", "z")
+
+        assert len(state.get_props("my-key")) == 2
+
+    with ResetUIEventsFrame(mr.app_runner) as frame:
+        frame.reset_state("my-key", "z")
+
+    with AppRunnerFrame(mr.app_runner) as frame:
+        # Cannot update event props when running user code:
+        with pytest.raises(Exception):
+            frame.update_state("my-key", "z", True)
+
+    with UIUpdatesFrame(mr.app_runner) as frame:
+        # Can update event props when Applying UI Updates:
+        frame.update_state("my-key", "z", True)
+        assert ("my-key", "z") in frame.event_mutations
+
+    with ResetUIEventsFrame(mr.app_runner) as frame:
+        # Can also update event props when resetting events:
+        frame.reset_state("my-key", "z")
+
+        # Cannot update non-event props while resetting events:
+        with pytest.raises(Exception):
+            frame.update_state("my-key", "x", 1)