{ lib, libjpeg_turbo, python3, ... }: python3.pkgs.buildPythonApplication { pname = "hhstream"; version = "0.1.0"; pyproject = true; src = ../.; build-system = [ python3.pkgs.setuptools ]; # `hhstream-pointer` is a Wayland client, so it needs libwayland's # marshalling; and it resolves keysym names against the XKB layout it # uploads, so it needs xkbcommon. # # Neither protocol XML is a build input: both generated modules are vendored # under src/hhstream_pointer/_protocol, so a checkout builds without a code # generator. See that package's docstring for why, and # hhstream_pointer._protocol.regenerate for how to refresh them -- including # the note that virtual-keyboard-unstable-v1.xml is not in wayland-protocols # or wlr-protocols in this nixpkgs and comes from pkgs.hyprland.src. dependencies = [ python3.pkgs.pywayland python3.pkgs.xkbcommon libjpeg_turbo ]; # The in-process jpeg encoder reaches libjpeg-turbo through `ctypes`, so the # library has to be *findable at run time*, which a propagated build input # alone does not achieve: nothing links it, so nothing puts its directory on # LD_LIBRARY_PATH. The wrapper is what makes `ctypes.util.find_library` succeed # inside the unit -- and it is the same library grim already links, so the # frames stay byte-compatible with the existing stream. # # Both variables, deliberately. `LD_LIBRARY_PATH` is the conventional one, but # a nix Python wrapper sets that variable *itself* -- which is how the unit # check failed with the library plainly present -- so `TURBOJPEG_PATH` is the # one that actually decides, and `jpeg._load_library` checks it first. makeWrapperArgs = [ "--prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath [ libjpeg_turbo ]}" # `lib.getLib`, not the bare package: the default output of libjpeg-turbo in # this nixpkgs is the *tools* (`-bin`), which has no `lib/` at all -- pointing # at it produced "cannot load libjpeg-turbo from .../-bin/lib/libturbojpeg.so". "--set TURBOJPEG_PATH ${lib.getLib libjpeg_turbo}/lib/libturbojpeg.so" ]; # Unit tests are wired up in the flake's `checks` so they can run without # installing the package; see docs/CONTRACT.md. doCheck = false; # Cheap proof that the vendored protocols still bind against this pywayland: # importing each runs the scanner-generated `_gen_c()` for its interfaces. pythonImportsCheck = [ "hhstream_pointer.ops" "hhstream_pointer.keymap" "hhstream_pointer._protocol.wlr_virtual_pointer_unstable_v1" "hhstream_pointer._protocol.virtual_keyboard_unstable_v1" # The web app: importing the server pulls in the router, the publisher and # the pages. "hhstream_live.server" # The capture backend and its vendored protocol bindings: importing the # backend runs the scanner-generated `_gen_c()` for wl_shm, wl_output and # zwlr-screencopy-manager-v1, which is the same cheap proof the pointer # driver gets above. "hhstream.wayland_capture" "hhstream._protocol.wlr_screencopy_unstable_v1" "hhstream.jpeg" ]; # `pythonImportsCheck` only *imports*, and `hhstream_live.phrase` reads its # wordlist lazily -- so a wheel that dropped `wordlist.txt` would sail past it # and fail at the first `enable` instead. Read the list for real, against the # installed tree, and mint a phrase so the generator and its validator are # proven on the same words. `doCheck = false` (the suite runs in the flake's # `checks`), so this is the only place the packaged data is exercised. postFixup = '' echo "checking the installed wordlist..." PYTHONPATH="$out/${python3.sitePackages}:$PYTHONPATH" ${python3.interpreter} -c ' import hhstream_live.phrase as phrase count = len(phrase.words()) assert count > 7000, f"wordlist has only {count} words; is wordlist.txt installed?" assert phrase.validate(phrase.generate()) print(f"wordlist ok: {count} words, ~{phrase.entropy_bits():.1f} bits a phrase") ' ''; meta = { description = "Publish a headless Hyprland session's frames on a Unix socket"; license = lib.licenses.mit; mainProgram = "hhstream-server"; }; }