limelight-app 0.0.1__tar.gz

limelight_app-0.0.1/.gitattributes

@@ -0,0 +1,36 @@
+# Line endings.
+#
+# This repository was carried between a Windows machine and a Linux one without
+# its history, and arrived with roughly two thirds of its text files stored as
+# CRLF and the rest as LF. Nothing enforced either, so any tool that rewrote a
+# file could silently convert one to the other and turn a small edit into a
+# whole-file diff.
+#
+# `text=auto` settles it: Git stores every text file with LF, and checks it out
+# with whatever the platform expects - CRLF on Windows where core.autocrlf is
+# set, LF here. The two working copies can now disagree about endings on disk
+# without disagreeing about the file.
+* text=auto
+
+# Formats where a byte that looks like a line ending is data, not formatting.
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.ico binary
+*.icns binary
+*.h5 binary
+*.pdf binary
+*.limelight binary
+
+# Stated explicitly rather than left to autodetection, so the intent survives a
+# file that happens to start with something that looks binary.
+*.py text
+*.dhall text
+*.md text
+*.txt text
+*.toml text
+*.yml text
+*.json text
+*.csv text
+*.html text
+*.hs text

limelight_app-0.0.1/.github/workflows/build-installers.yml

@@ -0,0 +1,144 @@
+name: Build installers
+
+# Installers cannot be cross-compiled: PyInstaller freezes the interpreter and
+# shared libraries of the machine it runs on, so each target needs its own
+# runner.
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version string for the artifact names"
+        required: false
+        default: "0.0.1"
+
+permissions:
+  contents: read
+
+jobs:
+  version:
+    runs-on: ubuntu-latest
+    outputs:
+      value: ${{ steps.resolve.outputs.value }}
+    steps:
+      - id: resolve
+        shell: bash
+        run: |
+          if [ "${GITHUB_REF_TYPE}" = "tag" ]; then
+            echo "value=${GITHUB_REF_NAME#v}" >> "$GITHUB_OUTPUT"
+          else
+            echo "value=${{ inputs.version || '0.0.1' }}" >> "$GITHUB_OUTPUT"
+          fi
+
+  build:
+    needs: version
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            target: linux
+          - os: windows-latest
+            target: windows
+          - os: macos-14
+            target: macos
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          # setuptools-scm reads the version from the tags.
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+
+      - name: Install project and build tools
+        shell: bash
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e .
+          python -m pip install pyinstaller
+
+      # Qt's GUI library links libEGL and libGL even for offscreen rendering,
+      # and the runner image has neither; libfuse2 is for the AppImage.
+      - name: Install Linux packaging dependencies
+        if: matrix.target == 'linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            libegl1 libgl1 libxkbcommon0 libfontconfig1 libdbus-1-3 libfuse2
+
+      # Renders with Qt and Pillow, so no runner needs extra tools. Only macOS
+      # has iconutil, so only there does it also produce the .icns.
+      - name: Build icons
+        run: python packaging/make_icons.py
+
+      - name: Build the application bundle
+        env:
+          LIMELIGHT_VERSION: ${{ needs.version.outputs.value }}
+        run: pyinstaller packaging/limelight.spec --noconfirm
+
+      # --------------------------------------------------------------- Linux
+      - name: Build .deb and AppImage
+        if: matrix.target == 'linux'
+        run: packaging/linux/build_linux_packages.sh "${{ needs.version.outputs.value }}"
+
+      # ------------------------------------------------------------- Windows
+      - name: Install Inno Setup
+        if: matrix.target == 'windows'
+        run: choco install innosetup --no-progress -y
+
+      - name: Build the Windows installer
+        if: matrix.target == 'windows'
+        shell: cmd
+        run: iscc /DAppVersion=${{ needs.version.outputs.value }} packaging\windows\limelight.iss
+
+      # --------------------------------------------------------------- macOS
+      - name: Build the disk image
+        if: matrix.target == 'macos'
+        run: packaging/macos/build_dmg.sh "${{ needs.version.outputs.value }}"
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: limelight-${{ matrix.target }}
+          path: dist/installer/*
+          if-no-files-found: error
+
+  # A tag push also publishes the three installers as a GitHub Release, with
+  # the matching section of CHANGELOG.md as its notes. Manual runs only leave
+  # workflow artifacts, so a test build never creates a release.
+  release:
+    needs: [version, build]
+    if: github.ref_type == 'tag'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/download-artifact@v8
+        with:
+          pattern: limelight-*
+          path: dist/installer
+          merge-multiple: true
+
+      - name: Extract the release notes from the changelog
+        shell: bash
+        run: |
+          version="${{ needs.version.outputs.value }}"
+          awk -v v="$version" '/^## \[/ { p = index($0, "[" v "]") > 0 } p' CHANGELOG.md > notes.md
+          if [ ! -s notes.md ]; then
+            echo "Limelight $version" > notes.md
+          fi
+          cat notes.md
+
+      - uses: softprops/action-gh-release@v3
+        with:
+          name: Limelight ${{ needs.version.outputs.value }}
+          body_path: notes.md
+          files: dist/installer/*
+          fail_on_unmatched_files: true

limelight_app-0.0.1/.github/workflows/publish.yml

@@ -0,0 +1,54 @@
+name: Publish to PyPI
+
+# A pushed v* tag uploads the sdist and wheel to PyPI through Trusted
+# Publishing: PyPI accepts this workflow's OIDC token in place of an API
+# token, so there is no secret to store. The workflow file name and the
+# environment name below are what the publisher on PyPI is registered
+# against; change either and the upload is refused.
+#
+# There is deliberately no manual trigger. A release on PyPI cannot be
+# replaced, so the only way to publish is the tag that names the version.
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    # A job-level permissions block replaces the workflow's, so contents has
+    # to be repeated here or the checkout cannot read the repository.
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          # setuptools-scm reads the version from the tags.
+          fetch-depth: 0
+
+      - uses: astral-sh/setup-uv@v10.1.0
+
+      - name: Build the sdist and wheel
+        run: uv build
+
+      # The version comes from the tag, so a mismatch here means the tag is
+      # not on a clean release commit. Better to stop than to upload a
+      # 0.0.2.dev0 that can never be removed.
+      - name: Check the built version matches the tag
+        run: |
+          expected="limelight_app-${GITHUB_REF_NAME#v}"
+          ls dist
+          for file in dist/*; do
+            case "$(basename "$file")" in
+              "$expected".tar.gz | "$expected"-py3-none-any.whl) ;;
+              *) echo "::error::$file does not match tag $GITHUB_REF_NAME"; exit 1 ;;
+            esac
+          done
+
+      - uses: pypa/gh-action-pypi-publish@release/v1

limelight_app-0.0.1/.gitignore

@@ -0,0 +1,8 @@
+.venv
+__pycache__
+_build/examples/example01-lotka-volterra.limelight
+_build
+dist/
+build/
+.pytest_cache/
+*.egg-info/

limelight_app-0.0.1/.vscode/launch.json

@@ -0,0 +1,29 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+
+        {
+            "name": "limelight: example20-wiki.limelight",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "src/limelight/__main__.py",
+            "cwd": "${workspaceFolder}",
+            "console": "integratedTerminal",
+            "args": [
+                //"_build/examples/example20-wiki.limelight"
+                "_build/examples/example30-largedataset.limelight"
+            ]
+        },
+
+        {
+            "name": "Python Debugger: Current File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        },
+    ]
+}

limelight_app-0.0.1/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+Notable changes to Limelight. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and versions follow
+[Semantic Versioning](https://semver.org/) once past 1.0; before that, minor
+versions may break things.
+
+## [Unreleased]
+
+## [0.0.1] - 2026-09-11
+
+First release on PyPI, as `limelight-app`.
+
+### Added
+
+- The `.limelight` package format: a folder or archive holding a Dhall
+  manifest, CSV and HDF5 datasets, figure specs, image assets, and a Markdown
+  story that walks a reader through the analysis. The language reference in
+  `src/limelight/language-reference/` defines it.
+- `limelight.writer`, the Python library that builds packages, and
+  `limelight.reader`, which opens them without the app.
+- The desktop app (`limelight-gui`): story, figures, datasets and control
+  parameters, with PDF export of the story.
+- `limelight-cli` with `summary`, `verify`, `json` and `pdf` subcommands, and
+  `LL` as a short form of both commands.
+- A built-in evaluator for the subset of Dhall that manifests use, so reading
+  a package needs no `dhall-to-json`; the tool is only consulted for
+  hand-written manifests that go beyond that subset.
+- Native installers for Windows, macOS and Linux under `packaging/`, with
+  `.limelight` file associations.
+
+[Unreleased]: https://github.com/mikehulluk/limelight/compare/v0.0.1...HEAD
+[0.0.1]: https://github.com/mikehulluk/limelight/releases/tag/v0.0.1

limelight_app-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mike Hull
+
+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.

limelight_app-0.0.1/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: limelight-app
+Version: 0.0.1
+Summary: A portable package format for data-driven figures and analysis stories, and a desktop app for reading them.
+Author-email: Mike Hull <mikehulluk@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mikehulluk/limelight
+Project-URL: Source, https://github.com/mikehulluk/limelight
+Project-URL: Issues, https://github.com/mikehulluk/limelight/issues
+Keywords: data,visualization,figures,plots,story,report,dhall,matplotlib,qt
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: X11 Applications :: Qt
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=42.0
+Requires-Dist: h5py>=3.10
+Requires-Dist: linkify-it-py>=2.0
+Requires-Dist: markdown-it-py[linkify]>=4.0
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: mdit-py-plugins>=0.6
+Requires-Dist: numpy>=1.26
+Requires-Dist: pillow>=10.0
+Requires-Dist: PySide6>=6.6
+Dynamic: license-file
+
+# Limelight
+
+Limelight is a portable package format for data-driven figures and analysis
+stories, and a desktop app for reading them.
+
+A Limelight package is a folder, or a `.limelight` archive with the same
+layout, holding a `project.dhall` manifest alongside the datasets it
+describes, the figure specs drawn from them, and a story that walks a reader
+through the analysis. The app opens either form, validates the manifest,
+resolves the data, renders the figures, and follows the story.
+
+Packages are meant to be produced by libraries and tools rather than by hand;
+`limelight.writer` is the Python library for building them, and
+`limelight.reader` for opening them without the app.
+
+## Installing
+
+```bash
+pip install limelight-app
+```
+
+The distribution is `limelight-app` (PyPI would not allow plain `limelight`),
+but the package imports as `limelight` and the commands are named as below.
+
+A package's `project.dhall` manifest is read by a built-in evaluator, so
+nothing beyond the Python dependencies is needed. A hand-written manifest
+that uses Dhall features beyond what the writer emits (functions, `if`,
+`merge`, interpolation) is handed to `dhall-to-json` instead, if one is on
+`PATH` or named by `LIMELIGHT_DHALL_TO_JSON`.
+
+Native installers for Windows, macOS and Linux are built by `packaging/`;
+see `packaging/README.md`.
+
+## Using it
+
+```bash
+limelight-gui example.limelight            # open a package in the desktop app
+limelight-cli summary example.limelight    # print a summary of a package
+limelight-cli verify example.limelight     # validate one or more packages
+limelight-cli pdf example.limelight        # render a package's story to PDF
+```
+
+`LL` is the short form of both: `LL example.limelight` opens the app, and
+`LL verify example.limelight` (or `summary`, `json`, `pdf`) runs the CLI.
+
+The scripts in `examples/` build sample packages into `_build/examples/`, and
+`src/limelight/language-reference/` holds the Dhall types a manifest is
+written against; the writer copies them into every package it builds.
+
+## Developing
+
+```bash
+uv sync --all-groups
+uv run pytest
+```

limelight_app-0.0.1/README.md

@@ -0,0 +1,55 @@
+# Limelight
+
+Limelight is a portable package format for data-driven figures and analysis
+stories, and a desktop app for reading them.
+
+A Limelight package is a folder, or a `.limelight` archive with the same
+layout, holding a `project.dhall` manifest alongside the datasets it
+describes, the figure specs drawn from them, and a story that walks a reader
+through the analysis. The app opens either form, validates the manifest,
+resolves the data, renders the figures, and follows the story.
+
+Packages are meant to be produced by libraries and tools rather than by hand;
+`limelight.writer` is the Python library for building them, and
+`limelight.reader` for opening them without the app.
+
+## Installing
+
+```bash
+pip install limelight-app
+```
+
+The distribution is `limelight-app` (PyPI would not allow plain `limelight`),
+but the package imports as `limelight` and the commands are named as below.
+
+A package's `project.dhall` manifest is read by a built-in evaluator, so
+nothing beyond the Python dependencies is needed. A hand-written manifest
+that uses Dhall features beyond what the writer emits (functions, `if`,
+`merge`, interpolation) is handed to `dhall-to-json` instead, if one is on
+`PATH` or named by `LIMELIGHT_DHALL_TO_JSON`.
+
+Native installers for Windows, macOS and Linux are built by `packaging/`;
+see `packaging/README.md`.
+
+## Using it
+
+```bash
+limelight-gui example.limelight            # open a package in the desktop app
+limelight-cli summary example.limelight    # print a summary of a package
+limelight-cli verify example.limelight     # validate one or more packages
+limelight-cli pdf example.limelight        # render a package's story to PDF
+```
+
+`LL` is the short form of both: `LL example.limelight` opens the app, and
+`LL verify example.limelight` (or `summary`, `json`, `pdf`) runs the CLI.
+
+The scripts in `examples/` build sample packages into `_build/examples/`, and
+`src/limelight/language-reference/` holds the Dhall types a manifest is
+written against; the writer copies them into every package it builds.
+
+## Developing
+
+```bash
+uv sync --all-groups
+uv run pytest
+```