anytimeline 0.1.0__tar.gz

anytimeline-0.1.0/.gitignore

@@ -0,0 +1,29 @@
+__pycache__/
+*.py[cod]
+.venv/
+.venv-*/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+node_modules/
+.DS_Store
+.ipynb_checkpoints/
+__marimo__/
+
+# built JavaScript bundle (npm run build in js/)
+src/anytimeline/static/
+
+# visual tests (Playwright)
+js/test/visual/dist/
+js/test/visual/scenes/
+js/test-results/
+js/playwright-report/
+
+# personal experiments (notebooks, scripts); not part of the project
+_scratch/
+
+# user documentation: the built site, and the plot bundle copied in by scripts/build_docs.py
+site/
+docs/user/assets/anytimeline/

anytimeline-0.1.0/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+All notable changes to anytimeline. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and versions follow
+[Semantic Versioning](https://semver.org/).
+
+## [0.1.0] - 2026-10-11
+
+The first release: interactive timeline charts for Jupyter, VS Code and marimo notebooks,
+drawn with WebGPU, WebGL2 or Canvas 2D.
+
+### Added
+
+- **Event charts** (`Timeline.events`): a mark per event on lanes, coloured, shaped and sized
+  by columns; overlapping events spread out; routes join the events of a group; labels and
+  tooltips. Time can be datetimes in any time zone and century, durations from nanoseconds,
+  or plain numbers; the **Order** scale spaces events by the order they happened in.
+- **Intervals and Gantt charts** (`Timeline.intervals`, `gantt`): bars from a start to an end,
+  packed per lane, with milestones, open bars, progress, dependency arrows and markers.
+- **Traces** (`Timeline.spans`, `anytimeline.otel.read_otlp`): spans as a waterfall that folds,
+  with each span's duration and the critical path; OpenTelemetry OTLP/JSON reader.
+- **States and values** (`Timeline.states`, `Timeline.values`): what state a lane was in, and
+  a number over time as a line, area or steps behind the events.
+- **Groups** (`group=` on every layer): hosts, days or runs as groups of lanes in one plot;
+  `Timeline(align="start")` compares groups from their start.
+- **Linked plots** (`Timeline.link`): separate plots that zoom and pan together.
+- **Sharing**: `save_html` (one file that works without Python), Save as PNG in the toolbar
+  and `Timeline.save_png`.
+- Toolbar with Pan, Zoom and Select tools, Time / Order, Back and Home, legend, text size and
+  full screen; selections come back to Python as rows of your tables; light and dark themes
+  that follow the notebook.
+- Synthetic example data (`anytimeline.synthetic`) and documentation with live examples.
+
+[0.1.0]: https://github.com/mluttikh/anytimeline/releases/tag/v0.1.0

anytimeline-0.1.0/LICENSE

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

anytimeline-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: anytimeline
+Version: 0.1.0
+Summary: GPU-accelerated timeline and event charts for notebooks
+Project-URL: Homepage, https://github.com/mluttikh/anytimeline
+Project-URL: Documentation, https://mluttikh.github.io/anytimeline/
+Project-URL: Repository, https://github.com/mluttikh/anytimeline
+Project-URL: Issues, https://github.com/mluttikh/anytimeline/issues
+Project-URL: Changelog, https://github.com/mluttikh/anytimeline/blob/main/CHANGELOG.md
+Author-email: mluttikh <mluttikhof@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: anywidget,event chart,gantt,jupyter,marimo,opentelemetry,timeline,traces,visualization,webgpu
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Jupyter
+Classifier: Framework :: Jupyter :: JupyterLab
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.12
+Requires-Dist: anywidget>=0.9.13
+Requires-Dist: ipywidgets>=8
+Requires-Dist: narwhals>=1.30
+Requires-Dist: numpy>=1.24
+Requires-Dist: traitlets>=5.9
+Description-Content-Type: text/markdown
+
+# anytimeline
+
+Interactive timeline and event charts for Jupyter and marimo notebooks, drawn on the GPU
+(WebGPU, WebGL2, or Canvas 2D on machines without a usable GPU).
+
+```bash
+pip install anytimeline
+```
+
+Documentation: <https://mluttikh.github.io/anytimeline/> · Changelog:
+[CHANGELOG.md](CHANGELOG.md) · Licence: MIT.
+
+Status: version 0.1. It draws **event charts**: one mark per event at the moment it
+happened, on lanes, so the order of what happened is easy to see. Time can be datetimes (any
+time zone, any century), durations from nanoseconds up, or plain numbers; a Time | Order switch
+spaces events by rank instead of time. Up to about a million events. It also draws **Gantt
+charts** and schedules: bars from a start to an end, with dependencies, progress and
+milestones, and overlapping bars stacked per lane; and **traces**: spans under spans.
+
+```python
+from anytimeline import Timeline
+from anytimeline.synthetic import service_log
+
+log = service_log()  # a dict of columns; any Polars, pandas or PyArrow table works too
+tl = Timeline()
+tl.events(
+    log,
+    time="time",
+    lane="service",
+    color="level",
+    symbol="event",
+    route="request",
+    order="seq",
+    tooltip=["request", "user", "bytes"],
+)
+tl  # click it, then scroll to zoom time; drag to pan; the toolbar has Zoom and Select
+```
+
+A Gantt chart from a table with a row per task:
+
+```python
+from anytimeline import gantt
+
+gantt(plan, task="task", start="start", end="end", depends="after", progress="done",
+      color="phase", today="2026-10-12")
+```
+
+Bars on other lanes (machines, people, services) come from `Timeline.intervals(...)`, and mix
+with events on the same lanes.
+
+Traces (OpenTelemetry, or any table of spans with a parent) plot as a waterfall that folds,
+with each span's duration and the critical path:
+
+```python
+from anytimeline import Timeline
+from anytimeline.otel import read_otlp
+
+tr = read_otlp("traces.jsonl")  # or anytimeline.synthetic.traces()
+Timeline().spans(tr.spans, color="service").events(tr.events, time="time", lane="span_id")
+```
+
+The toolbar has three tools: **Pan** (drag moves through time and lanes), **Zoom** (drag a
+time range to show it) and **Select** (drag a box, or click an event; the selection is rows of
+your table in `tl.selection`). Time and Order switch the scale; Aa sets the text size (also `Timeline(font_size=14)`).
+Press `?` in the plot for every mouse gesture and key; `f` or
+the button shows it full screen, where lanes fill the screen and overlapping events spread
+out.
+
+States (`Timeline.states`: up, degraded, down per lane) and values (`Timeline.values`: a
+number over time, as a line, area or steps) go on the same lanes, behind the events.
+
+`group="host"` on a layer puts each host's lanes under a header of their own, in one plot
+(`Timeline(align="start")` compares groups from their start); separate plots link with
+`a.link(b)` and zoom and pan together.
+
+`plot.save_html("plot.html")` writes the plot to one file that opens in any browser, still
+interactive; the toolbar saves it as a PNG, and so does `plot.save_png("plot.png")`.
+
+Documentation online: <https://mluttikh.github.io/anytimeline/>; or build it with
+`uv run python scripts/build_docs.py` and open `site/index.html`. Example notebook: [`examples/event_charts.ipynb`](examples/event_charts.ipynb). How the code
+is built: [`docs/architecture.md`](docs/architecture.md).
+
+## Development
+
+Needs Python (via [uv](https://docs.astral.sh/uv/)) and Node.js 20+ for the JavaScript bundle.
+
+```bash
+(cd js && npm ci && npm run build)    # build src/anytimeline/static/widget.js
+uv sync                               # create .venv with dev tools
+uv run pytest                         # Python tests
+(cd js && npm run typecheck && npm test)
+uv run ruff check . && uv run ruff format --check . && uv run ty check
+uv run python scripts/make_scenes.py  # scenes for the visual tests
+(cd js && npx playwright install chromium && npm run test:visual)  # every scene × backend, marimo
+uv run nbstripout --install           # once per clone: commit notebooks without outputs
+uv run python scripts/build_docs.py   # user documentation into site/ (examples run; warnings fail)
+uv run python scripts/build_docs.py serve   # preview it at http://localhost:8000
+```
+
+The user documentation is in `docs/user/`, built with [Zensical](https://zensical.org) and
+organised as tutorials, how-to guides, reference and explanation. Its examples are
+```` ```python exec="on" ```` blocks that run while building, and its plots are live: each
+example prints `plot._embed_html()`, which `standalone.js` draws in the page. The API
+reference comes from the docstrings (Google style). The browser tests check the built site
+too (`docs.spec.ts`, skipped until it is built).
+
+Visual tests draw the scenes in `js/test/visual/scenes/` with each backend and compare them
+with stored screenshots (macOS); `npm run test:visual:update` stores new ones after an
+intended change. `PERF=1 npx playwright test perf` measures a million events (after
+`uv run python scripts/make_scenes.py --million`).

anytimeline-0.1.0/README.md

@@ -0,0 +1,110 @@
+# anytimeline
+
+Interactive timeline and event charts for Jupyter and marimo notebooks, drawn on the GPU
+(WebGPU, WebGL2, or Canvas 2D on machines without a usable GPU).
+
+```bash
+pip install anytimeline
+```
+
+Documentation: <https://mluttikh.github.io/anytimeline/> · Changelog:
+[CHANGELOG.md](CHANGELOG.md) · Licence: MIT.
+
+Status: version 0.1. It draws **event charts**: one mark per event at the moment it
+happened, on lanes, so the order of what happened is easy to see. Time can be datetimes (any
+time zone, any century), durations from nanoseconds up, or plain numbers; a Time | Order switch
+spaces events by rank instead of time. Up to about a million events. It also draws **Gantt
+charts** and schedules: bars from a start to an end, with dependencies, progress and
+milestones, and overlapping bars stacked per lane; and **traces**: spans under spans.
+
+```python
+from anytimeline import Timeline
+from anytimeline.synthetic import service_log
+
+log = service_log()  # a dict of columns; any Polars, pandas or PyArrow table works too
+tl = Timeline()
+tl.events(
+    log,
+    time="time",
+    lane="service",
+    color="level",
+    symbol="event",
+    route="request",
+    order="seq",
+    tooltip=["request", "user", "bytes"],
+)
+tl  # click it, then scroll to zoom time; drag to pan; the toolbar has Zoom and Select
+```
+
+A Gantt chart from a table with a row per task:
+
+```python
+from anytimeline import gantt
+
+gantt(plan, task="task", start="start", end="end", depends="after", progress="done",
+      color="phase", today="2026-10-12")
+```
+
+Bars on other lanes (machines, people, services) come from `Timeline.intervals(...)`, and mix
+with events on the same lanes.
+
+Traces (OpenTelemetry, or any table of spans with a parent) plot as a waterfall that folds,
+with each span's duration and the critical path:
+
+```python
+from anytimeline import Timeline
+from anytimeline.otel import read_otlp
+
+tr = read_otlp("traces.jsonl")  # or anytimeline.synthetic.traces()
+Timeline().spans(tr.spans, color="service").events(tr.events, time="time", lane="span_id")
+```
+
+The toolbar has three tools: **Pan** (drag moves through time and lanes), **Zoom** (drag a
+time range to show it) and **Select** (drag a box, or click an event; the selection is rows of
+your table in `tl.selection`). Time and Order switch the scale; Aa sets the text size (also `Timeline(font_size=14)`).
+Press `?` in the plot for every mouse gesture and key; `f` or
+the button shows it full screen, where lanes fill the screen and overlapping events spread
+out.
+
+States (`Timeline.states`: up, degraded, down per lane) and values (`Timeline.values`: a
+number over time, as a line, area or steps) go on the same lanes, behind the events.
+
+`group="host"` on a layer puts each host's lanes under a header of their own, in one plot
+(`Timeline(align="start")` compares groups from their start); separate plots link with
+`a.link(b)` and zoom and pan together.
+
+`plot.save_html("plot.html")` writes the plot to one file that opens in any browser, still
+interactive; the toolbar saves it as a PNG, and so does `plot.save_png("plot.png")`.
+
+Documentation online: <https://mluttikh.github.io/anytimeline/>; or build it with
+`uv run python scripts/build_docs.py` and open `site/index.html`. Example notebook: [`examples/event_charts.ipynb`](examples/event_charts.ipynb). How the code
+is built: [`docs/architecture.md`](docs/architecture.md).
+
+## Development
+
+Needs Python (via [uv](https://docs.astral.sh/uv/)) and Node.js 20+ for the JavaScript bundle.
+
+```bash
+(cd js && npm ci && npm run build)    # build src/anytimeline/static/widget.js
+uv sync                               # create .venv with dev tools
+uv run pytest                         # Python tests
+(cd js && npm run typecheck && npm test)
+uv run ruff check . && uv run ruff format --check . && uv run ty check
+uv run python scripts/make_scenes.py  # scenes for the visual tests
+(cd js && npx playwright install chromium && npm run test:visual)  # every scene × backend, marimo
+uv run nbstripout --install           # once per clone: commit notebooks without outputs
+uv run python scripts/build_docs.py   # user documentation into site/ (examples run; warnings fail)
+uv run python scripts/build_docs.py serve   # preview it at http://localhost:8000
+```
+
+The user documentation is in `docs/user/`, built with [Zensical](https://zensical.org) and
+organised as tutorials, how-to guides, reference and explanation. Its examples are
+```` ```python exec="on" ```` blocks that run while building, and its plots are live: each
+example prints `plot._embed_html()`, which `standalone.js` draws in the page. The API
+reference comes from the docstrings (Google style). The browser tests check the built site
+too (`docs.spec.ts`, skipped until it is built).
+
+Visual tests draw the scenes in `js/test/visual/scenes/` with each backend and compare them
+with stored screenshots (macOS); `npm run test:visual:update` stores new ones after an
+intended change. `PERF=1 npx playwright test perf` measures a million events (after
+`uv run python scripts/make_scenes.py --million`).