starplast 0.42.0__tar.gz

starplast-0.42.0/LICENSE

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

starplast-0.42.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: starplast
+Version: 0.42.0
+Summary: Explore gene evidence and screen results in Toxoplasma and Plasmodium
+Author-email: Einar Olafsson <einar.olafsson@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/EinarOlafsson/starplast
+Project-URL: Documentation, https://einarolafsson.github.io/starplast/
+Project-URL: Issues, https://github.com/EinarOlafsson/starplast/issues
+Project-URL: Changelog, https://github.com/EinarOlafsson/starplast/blob/main/CHANGELOG.md
+Keywords: toxoplasma,plasmodium,bioinformatics,CRISPR,visualization
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: pyarrow>=12
+Requires-Dist: PyQt6>=6.5
+Requires-Dist: pyqtgraph>=0.13
+Requires-Dist: PyOpenGL>=3.1
+Requires-Dist: scikit-learn>=1.3
+Requires-Dist: umap-learn>=0.5
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: xlrd>=2.0.1
+Requires-Dist: pypdf>=4.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: matplotlib>=3.7
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=6; extra == "dev"
+Requires-Dist: tomli>=2; python_version < "3.11" and extra == "dev"
+Provides-Extra: docs
+Requires-Dist: pdoc<17,>=15; extra == "docs"
+Requires-Dist: markdown2<3,>=2.5; extra == "docs"
+Provides-Extra: ingest
+Requires-Dist: pyBigWig>=0.3; extra == "ingest"
+Provides-Extra: gpu
+Requires-Dist: cuml-cu12>=24.10; (sys_platform == "linux" and platform_machine == "x86_64") and extra == "gpu"
+Requires-Dist: cupy-cuda12x>=13.0; (sys_platform == "linux" and platform_machine == "x86_64") and extra == "gpu"
+Dynamic: license-file
+
+# Starplast
+
+Explore gene evidence and screen results in *Toxoplasma gondii* and
+*Plasmodium falciparum*.
+
+```bash
+pip install starplast
+starplast
+```
+
+Requires Python 3.10+, a display, and OpenGL. Built gene tables and graphs are
+included for offline browsing. Analysis runs on the CPU by default.
+Install `starplast[gpu]` for optional CUDA 12 acceleration on Linux x86_64.
+
+[Documentation](https://einarolafsson.github.io/starplast/) ·
+[Source code](https://github.com/EinarOlafsson/starplast)
+
+The package contains the application, analysis modules, and cached gene data.
+Use `starplast[ingest]` for optional genome-coverage import support.

starplast-0.42.0/README.md

@@ -0,0 +1,139 @@
+# Starplast
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="docs/assets/starplast-wordmark-white.svg">
+  <img src="docs/assets/starplast-wordmark.svg" alt="Starplast — a Toxoplasma silhouette enclosing a constellation" width="520">
+</picture>
+
+[![Python 3.10+](https://img.shields.io/badge/Python-3.10%2B-3776AB?logo=python&logoColor=white)](#install)
+[![Linux, macOS, Windows](https://img.shields.io/badge/Platforms-Linux%20%7C%20macOS%20%7C%20Windows-lightgrey)](#install)
+[![Qt / PyQt6](https://img.shields.io/badge/GUI-PyQt6-41CD52?logo=qt&logoColor=white)](https://einarolafsson.github.io/starplast/guide.html)
+[![MIT license](https://img.shields.io/github/license/EinarOlafsson/starplast?color=3DA639)](LICENSE)
+
+[![Documentation on main](https://github.com/EinarOlafsson/starplast/actions/workflows/docs.yml/badge.svg?branch=main&event=push)](https://github.com/EinarOlafsson/starplast/actions/workflows/docs.yml?query=branch%3Amain)
+[![Python API](https://img.shields.io/badge/API-reference-007EC6)](https://einarolafsson.github.io/starplast/API.html)
+[![GitHub issues](https://img.shields.io/github/issues/EinarOlafsson/starplast?logo=github)](https://github.com/EinarOlafsson/starplast/issues)
+[![spaCR integration](https://img.shields.io/badge/spaCR-integrated-7B61A8)](https://github.com/EinarOlafsson/spacr)
+
+Starplast is a desktop app for exploring gene evidence in *Toxoplasma gondii* and
+*Plasmodium falciparum*. It brings expression, fitness screens, localization,
+protein features, interactions, and literature annotations into one place.
+
+Use it to look up a gene, investigate hits from a screen, compare groups of genes,
+and choose candidates for follow-up experiments. The bundled maps contain 8,140
+*T. gondii* genes and 5,720 *P. falciparum* genes, viewed separately.
+
+[User guide](docs/guide.md) · [Python API](docs/API.md) ·
+[Dataset catalogue](docs/datasets.md) · [Changes](CHANGELOG.md)
+
+## Install
+
+Python 3.10 or newer is required. The desktop app needs a display and OpenGL.
+
+```bash
+pip install starplast
+starplast
+```
+
+From a checkout:
+
+```bash
+git clone https://github.com/EinarOlafsson/starplast.git
+cd starplast
+pip install -e .
+starplast
+```
+
+The default installation runs analyses on the CPU. For an NVIDIA GPU on Linux
+x86_64 with a CUDA 12 compatible driver:
+
+```bash
+pip install "starplast[gpu]"
+```
+
+GPU dependencies are large and optional. `starplast-install-gpu` can also inspect
+your driver and offer an installation command. macOS and Windows use CPU analysis;
+the 3D display still uses OpenGL.
+
+The built gene tables and graphs ship with the package. Browsing them works offline.
+Protein structures are downloaded when requested and cached locally. Rebuilding
+the bundled data requires the original source datasets.
+
+## Explore a screen
+
+1. Choose the organism under **File → Species**.
+2. Search for a gene ID. For *T. gondii*, **File → Import data** adds your screen results.
+3. Colour and filter the map using the measurements you want to compare.
+4. Click a gene to read its evidence and inspect each type of relationship separately.
+5. Select a group with a lasso or brush, then export the gene list for follow-up.
+
+[![A rotating gene map with CDPK1 and its connections illuminated](docs/screenshots/map_rotation.gif)](docs/screenshots/map_rotation.png)
+
+The *T. gondii* map with CDPK1 (`TGME49_301440`) selected. The selected gene and
+its five neighbours emit light; lines show attention-corrected literature
+co-mention links. Colours show compartments. [View a still image](docs/screenshots/map_rotation.png).
+
+Each point is a gene. Its position comes from an embedding of selected features;
+nearby points have similar inputs, but proximity alone does not demonstrate a
+shared function or physical interaction. Colours, relationship edges, and the
+evidence panel provide the context needed to interpret the map. Missing evidence
+is shown separately from measured values.
+
+The analysis panel lets you change feature sets, build embeddings, cluster genes,
+and evaluate recovery of labels held out from the input. Search scores help
+prioritize candidates; they are not experimental validation. See the
+[user guide](docs/guide.md) for controls and analysis settings.
+
+## Working with spaCR
+
+[spaCR](https://github.com/EinarOlafsson/spacr) handles microscopy and image-based
+screen analysis. Its Starplast launcher installs and opens this app in a separate
+Python environment. Starplast provides a place to explore the biological evidence
+around those screen results. Export a gene-level table from spaCR and import it
+into Starplast; launching the app does not transfer results automatically.
+
+## Data and reproducibility
+
+**[Full table of included data and source links →](docs/datasets.md)**
+
+The catalogue lists all 128 registered datasets and computed layers, with their
+measurements, coverage, publication references, and links to source data or inputs.
+Coverage differs by organism and assay;
+absence from a literature search does not establish that a gene has never been studied.
+
+```bash
+python -m starplast.paths       # show data locations and missing cache files
+python -m starplast.build_graph # rebuild from available source datasets
+```
+
+| Variable | Purpose |
+|---|---|
+| `STARPLAST_CACHE` | Override the directory containing built gene tables and graphs |
+| `STARPLAST_DATA` | Locate raw datasets used for rebuilding |
+| `STARPLAST_STATE` | Override the directory for saved runs, annotations, and downloads |
+
+Methods are described in [MATERIALS_AND_METHODS.md](MATERIALS_AND_METHODS.md).
+[HANDOFF.md](HANDOFF.md) contains the development history and earlier design decisions.
+The [repository review](docs/repository-review.md) describes the current architecture
+and its limitations.
+
+## Development
+
+```bash
+pip install -e ".[dev,docs]"
+QT_QPA_PLATFORM=offscreen pytest tests/test_app_smoke.py tests/test_docstrings.py -q
+python scripts/build_docs.py
+```
+
+Open `docs/site/index.html` for the guide and generated API reference.
+Some tests need source datasets, CUDA, or a working OpenGL context; see
+[development and releases](docs/releases.md) for the release checks.
+
+Develop on `nightly` and merge checked changes into `main`. To release, update all
+package and runtime versions together with `python scripts/release.py bump 0.43.0` and update
+the changelog before merging. A version increase on `main` triggers checks,
+builds, PyPI publishing, and a GitHub release. Ordinary merges do not publish.
+The initial PyPI account setup is described in the release guide.
+
+The source code is distributed under the [MIT license](LICENSE).
+Source datasets and third-party artwork retain their own licenses and attribution.

starplast-0.42.0/packaging/PYPI_README.md

@@ -0,0 +1,19 @@
+# Starplast
+
+Explore gene evidence and screen results in *Toxoplasma gondii* and
+*Plasmodium falciparum*.
+
+```bash
+pip install starplast
+starplast
+```
+
+Requires Python 3.10+, a display, and OpenGL. Built gene tables and graphs are
+included for offline browsing. Analysis runs on the CPU by default.
+Install `starplast[gpu]` for optional CUDA 12 acceleration on Linux x86_64.
+
+[Documentation](https://einarolafsson.github.io/starplast/) ·
+[Source code](https://github.com/EinarOlafsson/starplast)
+
+The package contains the application, analysis modules, and cached gene data.
+Use `starplast[ingest]` for optional genome-coverage import support.

starplast-0.42.0/pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "starplast"
+version = "0.42.0"
+description = "Explore gene evidence and screen results in Toxoplasma and Plasmodium"
+readme = "packaging/PYPI_README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "Einar Olafsson", email = "einar.olafsson@gmail.com"}]
+keywords = ["toxoplasma", "plasmodium", "bioinformatics", "CRISPR", "visualization"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+]
+dependencies = [
+    "numpy>=1.24",
+    "pandas>=2.0",
+    "pyarrow>=12",
+    "PyQt6>=6.5",
+    "pyqtgraph>=0.13",
+    "PyOpenGL>=3.1",
+    "scikit-learn>=1.3",
+    "umap-learn>=0.5",
+    "openpyxl>=3.1",
+    "xlrd>=2.0.1",
+    "pypdf>=4.0",
+    "networkx>=3.0",
+    "scipy>=1.10",
+    "matplotlib>=3.7"
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "build>=1.2", "twine>=6", "tomli>=2; python_version < '3.11'"]
+docs = ["pdoc>=15,<17", "markdown2>=2.5,<3"]
+ingest = ["pyBigWig>=0.3"]
+gpu = [
+    "cuml-cu12>=24.10; sys_platform == 'linux' and platform_machine == 'x86_64'",
+    "cupy-cuda12x>=13.0; sys_platform == 'linux' and platform_machine == 'x86_64'"
+]
+
+[project.scripts]
+starplast = "starplast.app:main"
+starplast-discover = "starplast.discover:main"
+starplast-install-gpu = "starplast.install_gpu:main"
+
+[project.urls]
+Homepage = "https://github.com/EinarOlafsson/starplast"
+Documentation = "https://einarolafsson.github.io/starplast/"
+Issues = "https://github.com/EinarOlafsson/starplast/issues"
+Changelog = "https://github.com/EinarOlafsson/starplast/blob/main/CHANGELOG.md"
+
+[tool.setuptools]
+packages = ["starplast"]
+include-package-data = false
+
+[tool.setuptools.package-data]
+starplast = ["data/*.npz", "data/*.parquet", "data/*.tsv", "data/*.tsv.gz", "data/*.json", "data/hf_release/*.parquet", "data/hf_release/*.md", "data/icons/*.svg"]
+
+[tool.setuptools.exclude-package-data]
+starplast = ["data/embeddings/*"]
+
+[tool.pytest.ini_options]
+markers = ["slow: runs a real build or a full documentation pass; minutes rather than seconds"]

starplast-0.42.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

starplast-0.42.0/starplast/__init__.py

@@ -0,0 +1,7 @@
+"""Explore gene evidence in Toxoplasma gondii and Plasmodium falciparum.
+
+Use the analysis modules from Python, ``starplast-discover`` for batch searches,
+or ``starplast`` for the desktop browser. The user guide and API examples are
+available at https://einarolafsson.github.io/starplast/.
+"""
+__version__ = "0.42.0"

starplast-0.42.0/starplast/__main__.py

@@ -0,0 +1,5 @@
+"""Run the browser with `python -m starplast`."""
+from starplast.app import main
+
+if __name__ == "__main__":
+    main()

starplast-0.42.0/starplast/ambient.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""A drifting field of soft colour blobs, behind the panels.
+
+Ported from spaCR's ambient background so the two programs look like one pair of tools, and kept to
+the one animation that was asked for -- the blobs -- with the same controls under the same names:
+speed, size, density, blur.
+
+The design decision worth carrying across: **position is a pure function of the clock**, two
+independent sines per blob rather than a random walk. A walk accumulates error, cannot be rewound,
+and gives a different picture every time a frame is dropped; a function of time can be asked for any
+instant, which is what makes the field paintable at whatever rate the window can manage and
+identical at the same `t` on any machine.
+
+Blobs are seeded on a jittered grid rather than uniformly at random. With a dozen of them, uniform
+sampling reliably leaves one corner empty and puts three in the middle -- which reads as a bug in
+the drawing rather than as a random arrangement.
+"""
+from __future__ import annotations
+
+import math
+import random
+from dataclasses import dataclass
+
+from PyQt6 import QtCore, QtGui, QtWidgets
+
+#: The controls, and the range each is allowed -- the same names and bounds spaCR uses, so a person
+#: who has set this up once does not have to learn it twice.
+SPEED_RANGE = (0.1, 4.0)
+SIZE_RANGE = (0.25, 2.5)
+DENSITY_RANGE = (0.25, 3.0)
+BLUR_RANGE = (0.0, 3.0)
+DEFAULT_SPEED = 1.0
+DEFAULT_SIZE = 1.0
+DEFAULT_DENSITY = 1.0
+DEFAULT_BLUR = 0.0
+
+#: How many blobs at density 1.0, and the grid they are seeded on.
+BLOB_COUNT = 12
+GRID = (4, 3)
+
+
+@dataclass
+class Blob:
+    """One blob: where it sits, how far and how fast it wanders, how it breathes."""
+    x: float
+    y: float
+    drift_x: float
+    drift_y: float
+    rate_x: float
+    rate_y: float
+    phase_x: float
+    phase_y: float
+    radius: float
+    pulse: float
+    pulse_rate: float
+    pulse_phase: float
+    color: int
+
+
+def field(seed: int = 0, density: float = DEFAULT_DENSITY) -> list:
+    """A reproducible set of blobs, seeded on a jittered grid.
+
+    The pool is always rolled at the top of the density range and a prefix of it painted, so raising
+    the density adds blobs rather than redrawing the ones already there: the random numbers are
+    consumed in the same order either way, and blob 3 keeps the numbers blob 3 always had.
+    """
+    rng = random.Random(seed)
+    cols, rows = GRID
+    cells = list(range(cols * rows))
+    rng.shuffle(cells)
+    pool = int(round(BLOB_COUNT * DENSITY_RANGE[1]))
+    blobs = []
+    for i in range(pool):
+        cell = cells[i % len(cells)]
+        col, row = cell % cols, cell // cols
+        small = (i % 3) == 0
+        lo, hi = (0.10, 0.18) if small else (0.22, 0.38)
+        blobs.append(Blob(
+            x=(col + 0.15 + 0.7 * rng.random()) / cols,
+            y=(row + 0.15 + 0.7 * rng.random()) / rows,
+            drift_x=rng.uniform(0.02, 0.09), drift_y=rng.uniform(0.02, 0.09),
+            rate_x=2 * math.pi / rng.uniform(19.0, 43.0),
+            rate_y=2 * math.pi / rng.uniform(23.0, 51.0),
+            phase_x=rng.uniform(0.0, 2 * math.pi), phase_y=rng.uniform(0.0, 2 * math.pi),
+            radius=rng.uniform(lo, hi), pulse=rng.uniform(0.05, 0.16),
+            pulse_rate=2 * math.pi / rng.uniform(11.0, 29.0),
+            pulse_phase=rng.uniform(0.0, 2 * math.pi),
+            # Round-robin, not a random pick: with three colours and a dozen blobs a random
+            # assignment leaves one colour missing about one run in fifty.
+            color=i))
+    keep = max(1, int(round(BLOB_COUNT * _clamp(density, DENSITY_RANGE))))
+    return blobs[:keep]
+
+
+def _clamp(value: float, bounds) -> float:
+    lo, hi = bounds
+    return float(min(max(value, lo), hi))
+
+
+def geometry(blobs, t: float, width: int, height: int, speed: float = DEFAULT_SPEED,
+             size: float = DEFAULT_SIZE) -> list:
+    """(cx, cy, radius, colour index) per blob, in pixels, at time `t`."""
+    short = max(min(width, height), 1)
+    out = []
+    tt = t * _clamp(speed, SPEED_RANGE)
+    for b in blobs:
+        cx = (b.x + b.drift_x * math.sin(b.rate_x * tt + b.phase_x)) * width
+        cy = (b.y + b.drift_y * math.sin(b.rate_y * tt + b.phase_y)) * height
+        r = b.radius * (1.0 + b.pulse * math.sin(b.pulse_rate * tt + b.pulse_phase))
+        out.append((cx, cy, max(r * short * _clamp(size, SIZE_RANGE), 1.0), b.color))
+    return out
+
+
+class AmbientWidget(QtWidgets.QWidget):
+    """The blob field, painted behind everything else.
+
+    Transparent to the mouse -- it is scenery, and a background that swallowed a click on the panel
+    in front of it would be a bug nobody could describe. The timer runs only while the widget is
+    visible, because sixty repaints a second of a picture nobody is looking at is sixty repaints a
+    second of a picture nobody is looking at.
+    """
+
+    def __init__(self, colors=None, background="#0b0d10", parent=None, seed: int = 0):
+        super().__init__(parent)
+        self.setAttribute(QtCore.Qt.WidgetAttribute.WA_TransparentForMouseEvents, True)
+        self.background = QtGui.QColor(background)
+        self.colors = [QtGui.QColor(c) for c in (colors or ["#43c6d8", "#7a5cd8", "#2a9fb0"])]
+        # `blob_size`, NOT `size`: QWidget.size() is a method, and an attribute of that name
+        # shadows it -- every caller asking this widget how big it is gets a float back and
+        # "'float' object is not callable" from somewhere that never mentioned size.
+        self.speed, self.blob_size, self.density = DEFAULT_SPEED, DEFAULT_SIZE, DEFAULT_DENSITY
+        self.blur = DEFAULT_BLUR
+        self.seed = seed
+        self.blobs = field(seed, self.density)
+        self._t = 0.0
+        self._timer = QtCore.QTimer(self)
+        self._timer.setInterval(40)                    # 25 fps: scenery, not an animation to watch
+        self._timer.timeout.connect(self._tick)
+
+    def configure(self, **kw) -> None:
+        """Set any of speed, size, density, blur, colors -- and rebuild if the count changed.
+
+        `size` is accepted under spaCR's name and stored as `blob_size`, since a widget cannot have
+        an attribute called `size`.
+        """
+        density = kw.pop("density", None)
+        if "size" in kw:
+            kw["blob_size"] = kw.pop("size")
+        for k, v in kw.items():
+            if k == "colors":
+                self.colors = [QtGui.QColor(c) for c in v]
+            elif hasattr(self, k):
+                setattr(self, k, float(v))
+        if density is not None and float(density) != self.density:
+            self.density = float(density)
+            self.blobs = field(self.seed, self.density)
+        self.update()
+
+    def start(self) -> None:
+        """Begin animating, if it is not already."""
+        if not self._timer.isActive():
+            self._timer.start()
+
+    def stop(self) -> None:
+        """Stop animating. The field keeps its time, so starting again continues rather than jumps."""
+        self._timer.stop()
+
+    def _tick(self) -> None:
+        self._t += self._timer.interval() / 1000.0
+        self.update()
+
+    def set_time(self, t: float) -> None:
+        """Jump to an instant. Position is a function of the clock, so this is exact."""
+        self._t = float(t)
+        self.update()
+
+    def showEvent(self, ev):
+        self.start()
+        super().showEvent(ev)
+
+    def hideEvent(self, ev):
+        self.stop()
+        super().hideEvent(ev)
+
+    def paintEvent(self, _ev):
+        p = QtGui.QPainter(self)
+        p.setRenderHint(QtGui.QPainter.RenderHint.Antialiasing)
+        p.fillRect(self.rect(), self.background)
+        p.setPen(QtCore.Qt.PenStyle.NoPen)
+        p.setCompositionMode(QtGui.QPainter.CompositionMode.CompositionMode_Plus)
+        for cx, cy, r, ci in geometry(self.blobs, self._t, self.width(), self.height(),
+                                      self.speed, self.blob_size):
+            base = self.colors[ci % len(self.colors)]
+            grad = QtGui.QRadialGradient(cx, cy, r)
+            # Alpha to zero at the rim rather than a hard edge: a blob with an edge is a circle, and
+            # a circle drifting behind a panel reads as a loading spinner.
+            inner = QtGui.QColor(base)
+            inner.setAlpha(int(70 * max(0.35, 1.0 - self.blur / (BLUR_RANGE[1] + 1e-9))))
+            outer = QtGui.QColor(base)
+            outer.setAlpha(0)
+            grad.setColorAt(0.0, inner)
+            grad.setColorAt(1.0, outer)
+            p.setBrush(QtGui.QBrush(grad))
+            p.drawEllipse(QtCore.QRectF(cx - r, cy - r, 2 * r, 2 * r))
+        p.end()