@pyscript/core 0.1.19 → 0.1.20

package/src/stdlib/pyweb/pydom.py

@@ -0,0 +1,314 @@
+import sys
+import warnings
+from functools import cached_property
+from typing import Any
+
+from pyodide.ffi import JsProxy
+from pyscript import display, document, window
+
+# from pyscript import when as _when
+
+alert = window.alert
+
+
+class BaseElement:
+    def __init__(self, js_element):
+        self._js = js_element
+        self._parent = None
+        self.style = StyleProxy(self)
+
+    def __eq__(self, obj):
+        """Check if the element is the same as the other element by comparing
+        the underlying JS element"""
+        return isinstance(obj, BaseElement) and obj._js == self._js
+
+    @property
+    def parent(self):
+        if self._parent:
+            return self._parent
+
+        if self._js.parentElement:
+            self._parent = self.__class__(self._js.parentElement)
+
+        return self._parent
+
+    @property
+    def __class(self):
+        return self.__class__ if self.__class__ != PyDom else Element
+
+    def create(self, type_, is_child=True, classes=None, html=None, label=None):
+        js_el = document.createElement(type_)
+        element = self.__class(js_el)
+
+        if classes:
+            for class_ in classes:
+                element.add_class(class_)
+
+        if html is not None:
+            element.html = html
+
+        if label is not None:
+            element.label = label
+
+        if is_child:
+            self.append(element)
+
+        return element
+
+    def find(self, selector):
+        """Return an ElementCollection representing all the child elements that
+        match the specified selector.
+
+        Args:
+            selector (str): A string containing a selector expression
+
+        Returns:
+            ElementCollection: A collection of elements matching the selector
+        """
+        elements = self._js.querySelectorAll(selector)
+        if not elements:
+            return None
+        return ElementCollection([Element(el) for el in elements])
+
+
+class Element(BaseElement):
+    @property
+    def children(self):
+        return [self.__class__(el) for el in self._js.children]
+
+    def append(self, child):
+        # TODO: this is Pyodide specific for now!!!!!!
+        # if we get passed a JSProxy Element directly we just map it to the
+        # higher level Python element
+        if isinstance(child, JsProxy):
+            return self.append(Element(child))
+
+        elif isinstance(child, Element):
+            self._js.appendChild(child._js)
+
+            return child
+
+        elif isinstance(child, ElementCollection):
+            for el in child:
+                self.append(el)
+
+    # -------- Pythonic Interface to Element -------- #
+    @property
+    def html(self):
+        return self._js.innerHTML
+
+    @html.setter
+    def html(self, value):
+        self._js.innerHTML = value
+
+    @property
+    def content(self):
+        # TODO: This breaks with with standard template elements. Define how to best
+        #       handle this specifica use case. Just not support for now?
+        if self._js.tagName == "TEMPLATE":
+            warnings.warn(
+                "Content attribute not supported for template elements.", stacklevel=2
+            )
+            return None
+        return self._js.innerHTML
+
+    @content.setter
+    def content(self, value):
+        # TODO: (same comment as above)
+        if self._js.tagName == "TEMPLATE":
+            warnings.warn(
+                "Content attribute not supported for template elements.", stacklevel=2
+            )
+            return
+
+        display(value, target=self.id)
+
+    @property
+    def id(self):
+        return self._js.id
+
+    @id.setter
+    def id(self, value):
+        self._js.id = value
+
+    def clone(self, new_id=None):
+        clone = Element(self._js.cloneNode(True))
+        clone.id = new_id
+
+        return clone
+
+    def remove_class(self, classname):
+        classList = self._js.classList
+        if isinstance(classname, list):
+            classList.remove(*classname)
+        else:
+            classList.remove(classname)
+        return self
+
+    def add_class(self, classname):
+        classList = self._js.classList
+        if isinstance(classname, list):
+            classList.add(*classname)
+        else:
+            self._js.classList.add(classname)
+        return self
+
+    @property
+    def classes(self):
+        classes = self._js.classList.values()
+        return [x for x in classes]
+
+    def show_me(self):
+        self._js.scrollIntoView()
+
+    def when(self, event, handler):
+        document.when(event, selector=self)(handler)
+
+
+class StyleProxy(dict):
+    def __init__(self, element: Element) -> None:
+        self._element = element
+
+    @cached_property
+    def _style(self):
+        return self._element._js.style
+
+    def __getitem__(self, key):
+        return self._style.getPropertyValue(key)
+
+    def __setitem__(self, key, value):
+        self._style.setProperty(key, value)
+
+    def remove(self, key):
+        self._style.removeProperty(key)
+
+    def set(self, **kws):
+        for k, v in kws.items():
+            self._element._js.style.setProperty(k, v)
+
+    # CSS Properties
+    # Reference: https://github.com/microsoft/TypeScript/blob/main/src/lib/dom.generated.d.ts#L3799C1-L5005C2
+    # Following prperties automatically generated from the above reference using
+    # tools/codegen_css_proxy.py
+    @property
+    def visible(self):
+        return self._element._js.style.visibility
+
+    @visible.setter
+    def visible(self, value):
+        self._element._js.style.visibility = value
+
+
+class StyleCollection:
+    def __init__(self, collection: "ElementCollection") -> None:
+        self._collection = collection
+
+    def __get__(self, obj, objtype=None):
+        return obj._get_attribute("style")
+
+    def __getitem__(self, key):
+        return self._collection._get_attribute("style")[key]
+
+    def __setitem__(self, key, value):
+        for element in self._collection._elements:
+            element.style[key] = value
+
+    def remove(self, key):
+        for element in self._collection._elements:
+            element.style.remove(key)
+
+
+class ElementCollection:
+    def __init__(self, elements: [Element]) -> None:
+        self._elements = elements
+        self.style = StyleCollection(self)
+
+    def __getitem__(self, key):
+        # If it's an integer we use it to access the elements in the collection
+        if isinstance(key, int):
+            return self._elements[key]
+        # If it's a slice we use it to support slice operations over the elements
+        # in the collection
+        elif isinstance(key, slice):
+            return ElementCollection(self._elements[key])
+
+        # If it's anything else (basically a string) we use it as a selector
+        # TODO: Write tests!
+        elements = self._element.querySelectorAll(key)
+        return ElementCollection([Element(el) for el in elements])
+
+    def __len__(self):
+        return len(self._elements)
+
+    def __eq__(self, obj):
+        """Check if the element is the same as the other element by comparing
+        the underlying JS element"""
+        return isinstance(obj, ElementCollection) and obj._elements == self._elements
+
+    def _get_attribute(self, attr, index=None):
+        if index is None:
+            return [getattr(el, attr) for el in self._elements]
+
+        # As JQuery, when getting an attr, only return it for the first element
+        return getattr(self._elements[index], attr)
+
+    def _set_attribute(self, attr, value):
+        for el in self._elements:
+            setattr(el, attr, value)
+
+    @property
+    def html(self):
+        return self._get_attribute("html")
+
+    @html.setter
+    def html(self, value):
+        self._set_attribute("html", value)
+
+    @property
+    def children(self):
+        return self._elements
+
+    def __iter__(self):
+        yield from self._elements
+
+    def __repr__(self):
+        return f"{self.__class__.__name__} (length: {len(self._elements)}) {self._elements}"
+
+
+class DomScope:
+    def __getattr__(self, __name: str) -> Any:
+        element = document[f"#{__name}"]
+        if element:
+            return element[0]
+
+
+class PyDom(BaseElement):
+    # Add objects we want to expose to the DOM namespace since this class instance is being
+    # remapped as "the module" itself
+    BaseElement = BaseElement
+    Element = Element
+    ElementCollection = ElementCollection
+
+    def __init__(self):
+        super().__init__(document)
+        self.ids = DomScope()
+        self.body = Element(document.body)
+        self.head = Element(document.head)
+
+    def create(self, type_, parent=None, classes=None, html=None):
+        return super().create(type_, is_child=False)
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            indices = range(*key.indices(len(self.list)))
+            return [self.list[i] for i in indices]
+
+        elements = self._js.querySelectorAll(key)
+        if not elements:
+            return None
+        return ElementCollection([Element(el) for el in elements])
+
+
+dom = PyDom()
+
+sys.modules[__name__] = dom

package/tests/integration/conftest.py

@@ -0,0 +1,184 @@
+import shutil
+import threading
+from http.server import HTTPServer as SuperHTTPServer
+from http.server import SimpleHTTPRequestHandler
+
+import pytest
+
+from .support import Logger
+
+
+def pytest_cmdline_main(config):
+    """
+    If we pass --clear-http-cache, we don't enter the main pytest logic, but
+    use our custom main instead
+    """
+
+    def mymain(config, session):
+        print()
+        print("-" * 20, "SmartRouter HTTP cache", "-" * 20)
+        # unfortunately pytest-cache doesn't offer a public API to selectively
+        # clear the cache, so we need to peek its internal. The good news is
+        # that pytest-cache is very old, stable and robust, so it's likely
+        # that this won't break anytime soon.
+        cache = config.cache
+        base = cache._cachedir.joinpath(cache._CACHE_PREFIX_VALUES, "pyscript")
+        if not base.exists():
+            print("No cache found, nothing to do")
+            return 0
+        #
+        print("Requests found in the cache:")
+        for f in base.rglob("*"):
+            if f.is_file():
+                # requests are saved in dirs named pyscript/http:/foo/bar, let's turn
+                # them into a proper url
+                url = str(f.relative_to(base))
+                url = url.replace(":/", "://")
+                print("    ", url)
+        shutil.rmtree(base)
+        print("Cache cleared")
+        return 0
+
+    if config.option.clear_http_cache:
+        from _pytest.main import wrap_session
+
+        return wrap_session(config, mymain)
+    return None
+
+
+def pytest_configure(config):
+    """
+    THIS IS A WORKAROUND FOR A pytest QUIRK!
+
+    At the moment of writing this conftest defines two new options, --dev and
+    --no-fake-server, but because of how pytest works, they are available only
+    if this is the "root conftest" for the test session.
+
+    This means that if you are in the pyscriptjs directory:
+
+    $ py.test                       # does NOT work
+    $ py.test tests/integration/    # works
+
+    This happens because there is also test py-unit directory, so in the first
+    case the "root conftest" would be tests/conftest.py (which doesn't exist)
+    instead of this.
+
+    There are various workarounds, but for now we can just detect it and
+    inform the user.
+
+    Related StackOverflow answer: https://stackoverflow.com/a/51733980
+    """
+    if not hasattr(config.option, "dev"):
+        msg = """
+        Running a bare "pytest" command from the pyscriptjs directory
+        is not supported. Please use one of the following commands:
+            - pytest tests/integration
+            - pytest tests/py-unit
+            - pytest tests/*
+            - cd tests/integration; pytest
+        """
+        pytest.fail(msg)
+    else:
+        if config.option.dev:
+            config.option.headed = True
+            config.option.no_fake_server = True
+
+
+@pytest.fixture(scope="session")
+def logger():
+    return Logger()
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--no-fake-server",
+        action="store_true",
+        help="Use a real HTTP server instead of http://fakeserver",
+    )
+    parser.addoption(
+        "--dev",
+        action="store_true",
+        help="Automatically open a devtools panel. Implies --headed and --no-fake-server",
+    )
+    parser.addoption(
+        "--clear-http-cache",
+        action="store_true",
+        help="Clear the cache of HTTP requests for SmartRouter",
+    )
+
+
+@pytest.fixture(scope="session")
+def browser_type_launch_args(request):
+    """
+    Override the browser_type_launch_args defined by pytest-playwright to
+    support --devtools.
+
+    NOTE: this has been tested with pytest-playwright==0.3.0. It might break
+    with newer versions of it.
+    """
+    # this calls the "original" fixture defined by pytest_playwright.py
+    launch_options = request.getfixturevalue("browser_type_launch_args")
+    if request.config.option.dev:
+        launch_options["devtools"] = True
+    return launch_options
+
+
+class DevServer(SuperHTTPServer):
+    """
+    Class for wrapper to run SimpleHTTPServer on Thread.
+    Ctrl +Only Thread remains dead when terminated with C.
+    Keyboard Interrupt passes.
+    """
+
+    def __init__(self, base_url, *args, **kwargs):
+        self.base_url = base_url
+        super().__init__(*args, **kwargs)
+
+    def run(self):
+        try:
+            self.serve_forever()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            self.server_close()
+
+
+@pytest.fixture(scope="session")
+def dev_server(logger):
+    class MyHTTPRequestHandler(SimpleHTTPRequestHandler):
+        enable_cors_headers = True
+
+        @classmethod
+        def my_headers(cls):
+            if cls.enable_cors_headers:
+                return {
+                    "Cross-Origin-Embedder-Policy": "require-corp",
+                    "Cross-Origin-Opener-Policy": "same-origin",
+                }
+            return {}
+
+        def end_headers(self):
+            self.send_my_headers()
+            SimpleHTTPRequestHandler.end_headers(self)
+
+        def send_my_headers(self):
+            for k, v in self.my_headers().items():
+                self.send_header(k, v)
+
+        def log_message(self, fmt, *args):
+            logger.log("http_server", fmt % args, color="blue")
+
+    host, port = "localhost", 8080
+    base_url = f"http://{host}:{port}"
+
+    # serve_Run forever under thread
+    server = DevServer(base_url, (host, port), MyHTTPRequestHandler)
+
+    thread = threading.Thread(None, server.run)
+    thread.start()
+
+    yield server  # Transition to test here
+
+    # End thread
+    server.shutdown()
+    thread.join()