fasthtml-tailwindcss 4.3.3__py3-none-win_amd64.whl

fasthtml_tailwindcss/__init__.py

@@ -0,0 +1,33 @@
+from collections.abc import Sequence
+from pathlib import Path
+from weakref import finalize
+
+from fasthtml.common import Style
+
+from ._client import Session, configuration
+
+__all__ = ["TailwindHead"]
+
+
+class TailwindHead:
+    def __init__(
+        self,
+        *,
+        watch: bool = False,
+        sources: Sequence[str | Path] | None = None,
+        input: str | Path | None = None,
+        css: str | None = None,
+    ) -> None:
+        config = configuration(watch=watch, sources=sources, input=input, css=css)
+        self._session = Session(config)
+        self._session.start()
+        finalize(self, self._session.close)
+
+    def __deepcopy__(self, memo):
+        return self
+
+    def __ft__(self):
+        if self._session.error:
+            raise RuntimeError(self._session.error)
+        css = self._session.output.read_text(encoding="utf-8")
+        return Style(css.replace("</", "<\\/"))

fasthtml_tailwindcss/_client.py

@@ -0,0 +1,156 @@
+import hashlib
+import json
+import os
+import subprocess
+import sys
+import time
+from importlib.metadata import version
+from pathlib import Path
+from threading import Event, Thread
+
+from filelock import FileLock, Timeout
+from platformdirs import user_cache_path
+
+IDLE_TIMEOUT = 15
+
+
+def configuration(*, watch, sources, input, css):
+    if isinstance(sources, (str, Path)):
+        raise TypeError("sources must be a sequence of paths, for example ['app']")
+    cwd = Path.cwd().resolve()
+    root = next(
+        (p for p in (cwd, *cwd.parents) if (p / "pyproject.toml").is_file()), cwd
+    )
+    input_path = (root / input).resolve() if input is not None else None
+    if input_path is not None and not input_path.is_file():
+        raise FileNotFoundError(input_path)
+    if sources is None:
+        sources = [root] if input is None else []
+    return {
+        "root": str(root),
+        "watch": watch,
+        "sources": [str((root / path).resolve()) for path in sources],
+        "input": str(input_path) if input_path is not None else None,
+        "css": css or "",
+        "version": version("fasthtml-tailwindcss"),
+    }
+
+
+def cache_directory(config):
+    settings = json.dumps(config, sort_keys=True).encode()
+    key = hashlib.sha256(settings).hexdigest()[:24]
+    return user_cache_path("fasthtml-tailwindcss", appauthor=False) / key
+
+
+def running(directory):
+    try:
+        with FileLock(str(directory / "worker.lock"), timeout=0):
+            return False
+    except Timeout:
+        return True
+
+
+def stop_process(process):
+    if process.poll() is not None:
+        return
+    process.terminate()
+    try:
+        process.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        process.wait()
+
+
+class Session:
+    def __init__(self, config):
+        self.config = config
+        self.directory = cache_directory(config)
+        self.output = self.directory / "style.css"
+        self.error = ""
+        self._closed = Event()
+        self._thread = Thread(target=self.heartbeat, daemon=True)
+
+    def connect(self):
+        self.directory.mkdir(parents=True, exist_ok=True, mode=0o700)
+        with FileLock(str(self.directory / "startup.lock"), timeout=30):
+            self.wait_for_previous_worker()
+            if not running(self.directory):
+                self.start_worker()
+            (self.directory / "heartbeat").touch()
+
+    def wait_for_previous_worker(self):
+        deadline = time.monotonic() + 10
+        while running(self.directory) and not (self.directory / "pid").exists():
+            if time.monotonic() > deadline:
+                raise RuntimeError("Tailwind helper is not responding")
+            time.sleep(0.05)
+
+    def start_worker(self):
+        for name in ("style.css", "error", "pid"):
+            (self.directory / name).unlink(missing_ok=True)
+        (self.directory / "config.json").write_text(
+            json.dumps(self.config), encoding="utf-8"
+        )
+        (self.directory / "heartbeat").touch()
+        flags = 0
+        if os.name == "nt":
+            flags = subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
+        with (self.directory / "helper.log").open("w") as log:
+            process = subprocess.Popen(
+                [
+                    sys.executable,
+                    "-m",
+                    "fasthtml_tailwindcss._worker",
+                    str(self.directory),
+                ],
+                stdin=subprocess.DEVNULL,
+                stdout=log,
+                stderr=log,
+                start_new_session=os.name != "nt",
+                creationflags=flags,
+            )
+        deadline = time.monotonic() + 10
+        while not (self.directory / "pid").exists():
+            if process.poll() is not None or time.monotonic() > deadline:
+                stop_process(process)
+                raise RuntimeError(
+                    (self.directory / "helper.log").read_text()
+                    or "Cannot start Tailwind helper"
+                )
+            time.sleep(0.05)
+
+    def wait_for_css(self):
+        deadline = time.monotonic() + 120
+        while not self.output.exists():
+            if self.error:
+                raise RuntimeError(self.error)
+            if time.monotonic() > deadline:
+                raise RuntimeError(
+                    "Tailwind initial build timed out; see compiler.log in the cache"
+                )
+            time.sleep(0.05)
+
+    def heartbeat(self):
+        while not self._closed.is_set():
+            error = self.directory / "error"
+            if error.exists():
+                self.error = error.read_text(encoding="utf-8")
+            elif not running(self.directory):
+                self.error = "Tailwind helper stopped; restart the application"
+            if self.error:
+                return
+            (self.directory / "heartbeat").touch()
+            self._closed.wait(2)
+
+    def start(self):
+        self.connect()
+        self._thread.start()
+        try:
+            self.wait_for_css()
+        except BaseException:
+            self.close()
+            raise
+
+    def close(self):
+        self._closed.set()
+        self._thread.join()

fasthtml_tailwindcss/_worker.py

@@ -0,0 +1,133 @@
+import json
+import os
+import re
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from filelock import FileLock
+
+from ._client import IDLE_TIMEOUT, stop_process
+
+
+def input_css(config):
+    def quote(path):
+        return json.dumps(Path(path).as_posix(), ensure_ascii=False)
+
+    base = (
+        f"@import {quote(config['input'])};"
+        if config["input"]
+        else '@import "tailwindcss" source(none);'
+    )
+    sources = "\n".join(f"@source {quote(path)};" for path in config["sources"])
+    return f"{base}\n{sources}\n{config['css']}\n"
+
+
+class Worker:
+    def __init__(self, directory):
+        self.directory = directory
+        self.config = json.loads((directory / "config.json").read_text())
+        self.output = directory / "style.css"
+        self.stopping = False
+
+    def stop(self, *_):
+        self.stopping = True
+
+    def start_compiler(self):
+        source = self.directory / "input.css"
+        source.write_text(input_css(self.config), encoding="utf-8")
+        executable = "tailwindcss.exe" if os.name == "nt" else "tailwindcss"
+        binary = Path(__file__).parent / "bin" / executable
+        mode = "--watch=always" if self.config["watch"] else "--minify"
+        command = [
+            str(binary),
+            "-i",
+            str(source),
+            "-o",
+            str(self.directory / "building.css"),
+            mode,
+        ]
+        with (self.directory / "compiler.log").open("w") as log:
+            return subprocess.Popen(
+                command,
+                cwd=self.config["root"],
+                stdin=subprocess.DEVNULL,
+                stdout=log,
+                stderr=log,
+                env={**os.environ, "NO_COLOR": "1"},
+            )
+
+    def publish_css(self):
+        css = (self.directory / "building.css").read_bytes()
+        if self.output.exists() and self.output.read_bytes() == css:
+            return
+        temporary = self.directory / "published.tmp"
+        temporary.write_bytes(css)
+        temporary.replace(self.output)
+
+    def idle(self):
+        heartbeat = (self.directory / "heartbeat").stat().st_mtime
+        return time.time() - heartbeat > IDLE_TIMEOUT
+
+    def expired(self):
+        if not self.idle():
+            return False
+        with FileLock(str(self.directory / "startup.lock"), timeout=30):
+            if not self.idle():
+                return False
+            (self.directory / "pid").unlink(missing_ok=True)
+            return True
+
+    def check_exit(self, code):
+        if code is None:
+            return
+        if code == 0 and not self.config["watch"] and self.output.exists():
+            return
+        details = (self.directory / "compiler.log").read_text(
+            encoding="utf-8", errors="replace"
+        )
+        raise RuntimeError(f"Tailwind stopped (exit {code}):\n{details}")
+
+    def monitor(self, process):
+        with (self.directory / "compiler.log").open(
+            encoding="utf-8", errors="replace"
+        ) as log:
+            pending = ""
+            while not self.stopping:
+                code = process.poll()
+                pending += log.read()
+                message, _, pending = pending.rpartition("\n")
+                if re.search(r"\bDone in\b", message):
+                    self.publish_css()
+                self.check_exit(code)
+                if self.expired():
+                    return
+                time.sleep(0.1)
+
+    def run(self):
+        process = None
+        (self.directory / "pid").write_text(str(os.getpid()))
+        try:
+            process = self.start_compiler()
+            self.monitor(process)
+        except (OSError, RuntimeError) as error:
+            (self.directory / "error").write_text(str(error), encoding="utf-8")
+        finally:
+            if process is not None:
+                stop_process(process)
+            (self.directory / "pid").unlink(missing_ok=True)
+
+
+def main(directory):
+    worker = Worker(directory)
+    for name in ("SIGTERM", "SIGINT", "SIGBREAK"):
+        if signum := getattr(signal, name, None):
+            signal.signal(signum, worker.stop)
+    with FileLock(str(directory / "worker.lock"), timeout=0):
+        worker.run()
+
+
+if __name__ == "__main__":
+    main(Path(sys.argv[1]))

fasthtml_tailwindcss/bin/tailwindcss.exe

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: fasthtml_tailwindcss/bin/tailwindcss.exe
+size: 112503296 bytes
+sha256: e0e260ce048014e9268f6237ff18f8ccf02cef521cbd0ae04e82c2cdf7aa3955

fasthtml_tailwindcss-4.3.3.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.5
+Name: fasthtml-tailwindcss
+Version: 4.3.3
+Summary: Tailwind CSS for FastHTML with a persistent compiler across server reloads and watch mode for automatic CSS rebuilds.
+Project-URL: Documentation, https://github.com/SpaceShaman/fasthtml-tailwindcss#readme
+Project-URL: Homepage, https://github.com/SpaceShaman/fasthtml-tailwindcss
+Project-URL: Issues, https://github.com/SpaceShaman/fasthtml-tailwindcss/issues
+Project-URL: Repository, https://github.com/SpaceShaman/fasthtml-tailwindcss
+Author-email: SpaceShaman <spaceshaman@tuta.io>
+License-Expression: MIT
+License-File: LICENSE
+License-File: TAILWIND-LICENSE
+Keywords: components,css,fasthtml,tailwindcss,web
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: filelock>=3.16
+Requires-Dist: platformdirs>=4
+Requires-Dist: python-fasthtml>=0.14.13
+Description-Content-Type: text/markdown
+
+# fasthtml-tailwindcss
+
+[![License](https://img.shields.io/github/license/SpaceShaman/fasthtml-tailwindcss)](LICENSE)
+[![Release](https://img.shields.io/github/actions/workflow/status/SpaceShaman/fasthtml-tailwindcss/release.yml?label=release)](https://github.com/SpaceShaman/fasthtml-tailwindcss/actions/workflows/release.yml)
+[![Python versions](https://img.shields.io/pypi/pyversions/fasthtml-tailwindcss)](https://pypi.org/project/fasthtml-tailwindcss/)
+[![PyPI version](https://img.shields.io/pypi/v/fasthtml-tailwindcss)](https://pypi.org/project/fasthtml-tailwindcss/)
+[![FastHTML](https://img.shields.io/badge/framework-FastHTML-7854F7)](https://github.com/AnswerDotAI/fasthtml)
+[![Tailwind CSS](https://img.shields.io/badge/CSS-Tailwind_CSS-06B6D4?logo=tailwindcss&logoColor=white)](https://tailwindcss.com/)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+[![Pytest](https://img.shields.io/badge/testing-pytest-0A9EDC?logo=pytest)](https://docs.pytest.org/)
+[![Ruff](https://img.shields.io/badge/linting-Ruff-D7FF64?logo=ruff)](https://github.com/astral-sh/ruff)
+
+Tailwind CSS for [FastHTML](https://github.com/AnswerDotAI/fasthtml) with a persistent compiler across server reloads and watch mode for automatic CSS rebuilds.
+
+## Installation
+
+Install with uv:
+
+```sh
+uv add fasthtml-tailwindcss
+```
+
+Or with pip:
+
+```sh
+pip install fasthtml-tailwindcss
+```
+
+On Alpine Linux, the standalone compiler also requires the system C++ runtime:
+
+```sh
+apk add --no-cache libstdc++ libgcc
+```
+
+## Usage
+
+```python
+from fasthtml.common import Div, FastHTML
+from fasthtml_tailwindcss import TailwindHead
+
+app = FastHTML(hdrs=[TailwindHead(watch=True)])
+
+
+@app.route("/")
+def get():
+    return Div("Hello", cls="rounded-lg bg-blue-500 p-4 text-white")
+```
+
+Run your application normally, for example with `uv run uvicorn main:app --reload`. The package bundles the official standalone Tailwind compiler: no Node.js, npm, CDN, CSS endpoint or additional command is needed.
+
+`TailwindHead` builds CSS when the component is constructed, usually while importing your application module, and waits for the first successful compilation. It embeds the result in a `<style>` element. Each full page receives the latest completed CSS. Refresh the browser to see updates; automatic browser refresh and updating styles during HTMX fragment swaps are not included.
+
+- `watch=True`: compile once, then watch source files. The compiler survives application reloads.
+- `watch=False` (default): compile once with minification, then reuse the result across reloads. Source changes do not rebuild CSS during that session.
+
+A local helper keeps the session alive while applications renew a shared heartbeat file, and shuts down 15 seconds after the last heartbeat. A quick manual restart is treated like a reload. A later start creates a fresh session and builds again. The session stays active while the component exists in a running Python process; it does not depend on ASGI lifespan.
+
+## Options
+
+All configuration is passed to `TailwindHead`:
+
+```python
+TailwindHead(
+    watch=True,
+    sources=["app"],
+    css="@theme { --color-brand: #7854f7; }",
+)
+```
+
+For a custom input stylesheet:
+
+```python
+TailwindHead(watch=True, input="assets/app.css")
+```
+
+- `sources`: source files or directories. Defaults to the project directory with the built-in input; with a custom input, its own source detection is used unless extra sources are supplied.
+- `input`: optional stylesheet replacing the built-in `@import "tailwindcss"`. Relative CSS imports resolve from that file.
+- `css`: optional inline CSS appended after the input. Useful for `@theme`, variants and explicit `@source inline(...)` declarations.
+
+Paths are resolved relative to the nearest `pyproject.toml` above the working directory, or the working directory if none exists. Sessions are shared by project, configuration and OS user. Reloads and application workers with identical options reuse the same session. Changing options, including `watch`, starts a separate session immediately; the unused session shuts down after 15 seconds.
+
+Tailwind scans complete class names in source files. Use `"bg-red-500"` rather than constructing names such as `f"bg-{color}-500"`. Classes inside installed component libraries need explicit sources or safelisting.
+
+Generated files and compiler diagnostics (`compiler.log`) live in the OS user cache under `fasthtml-tailwindcss`. Nothing is written into your application or installed package. Inline CSS requires an appropriate Content Security Policy if your application sets one.
+
+## Development
+
+```sh
+uv sync --group test
+uv run --group test pytest
+uv build
+```
+
+Wheel builds download and verify the matching official standalone executable. Wheels target Linux x64/ARM64 (glibc 2.28+ or musl 1.2+), macOS 13+ (Intel/Apple Silicon), and Windows x64. Source distributions contain the build hook and checksum manifest; building one requires network access unless the verified compiler is already present locally.
+
+The package version follows Tailwind, with `.postN` for Python-only fixes. The release workflow checks upstream daily, tests the platform wheels and publishes through PyPI Trusted Publishing. Configure the publisher for `SpaceShaman/fasthtml-tailwindcss`, workflow `release.yml`, environment `pypi`; allow workflow version commits on the default branch.
+
+## Links
+
+- [GitHub repository](https://github.com/SpaceShaman/fasthtml-tailwindcss)
+- [PyPI package](https://pypi.org/project/fasthtml-tailwindcss/)
+
+## License
+
+The wrapper and Tailwind CSS are MIT licensed. Both license notices are included in distributions.

fasthtml_tailwindcss-4.3.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+fasthtml_tailwindcss/__init__.py,sha256=9qlV1IwoaxbUYNXawc1WOd9-0WR-PwltvNLv3_NRk3A,904
+fasthtml_tailwindcss/_client.py,sha256=J0XOGBsMZ5l9jrHCLS8--Fdava3gWHs1boUXRx07rdQ,5161
+fasthtml_tailwindcss/_worker.py,sha256=p9Jof8fBZpBd7nRBeSdS5oYwHHyM3nouIBVnkZVciPg,4248
+fasthtml_tailwindcss/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fasthtml_tailwindcss/bin/tailwindcss.exe,sha256=4OJgzgSAFOkmj2I3_xj4zPAs71IcvQrgToLCzfeqOVU,112503296
+fasthtml_tailwindcss-4.3.3.dist-info/METADATA,sha256=RGiE7u8dytZ-CQjmMFzfTDgSwKJYdwmlcrlwMZp8QIo,7022
+fasthtml_tailwindcss-4.3.3.dist-info/WHEEL,sha256=A7YmR1UrJozxyeLCzQFwQUdR7CRUwkFKasEDmnrjVxY,94
+fasthtml_tailwindcss-4.3.3.dist-info/licenses/LICENSE,sha256=KYkziQfBpa3S7SN2jqaYr5uJyWlgUpnTzCAzRDPkZA4,1068
+fasthtml_tailwindcss-4.3.3.dist-info/licenses/TAILWIND-LICENSE,sha256=YOC2jA81wHju86XSlBnQsD_4TsHfnD-dbjmlGaWueYU,1071
+fasthtml_tailwindcss-4.3.3.dist-info/RECORD,,

fasthtml_tailwindcss-4.3.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64

fasthtml_tailwindcss-4.3.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SpaceShaman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fasthtml_tailwindcss-4.3.3.dist-info/licenses/TAILWIND-LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Tailwind Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.