tinto 0.1.0__tar.gz

tinto-0.1.0/.github/README.md

@@ -0,0 +1,115 @@
+# <img src="../docs/_static/logo.svg" alt="Tinto logo" width="48" valign="middle" /> Tinto
+
+
+[![PyPI Status](https://img.shields.io/pypi/v/tinto.svg)](https://pypi.python.org/pypi/tinto)
+[![Build Status](https://github.com/balouf/tinto/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/balouf/tinto/actions?query=workflow%3Abuild)
+[![Documentation Status](https://github.com/balouf/tinto/actions/workflows/docs.yml/badge.svg?branch=main)](https://github.com/balouf/tinto/actions?query=workflow%3Adocs)
+[![License: MIT](https://img.shields.io/badge/license-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code Coverage](https://codecov.io/gh/balouf/tinto/branch/main/graphs/badge.svg)](https://codecov.io/gh/balouf/tinto/tree/main)
+
+How long does a self-stabilizing graph coloring take to settle? Tinto measures it with a Numba-compiled Monte Carlo over pluggable graphs, guards, schedulers and recoloring rules, down to the variance and skewness of the stabilization time. For the conflict-guard rule under the random central daemon, it also provides exact results.
+
+
+- Free software: MIT
+- Documentation: <https://balouf.github.io/tinto/>.
+- Github: <https://github.com/balouf/tinto>
+
+
+## Features
+
+- Numba-compiled dynamics: CSR graphs (line, ring, uniform labeled tree,
+  Erdős-Rényi `G(n, p)`, bipartite `G(n1, n2, p)`), pluggable guards,
+  four schedulers (shuffled, ordered, Bernoulli, independent) and five
+  colorers (lowest, next or uniform free color, plus two blind variants
+  that may leave clashes behind).
+- Monte-Carlo driver aggregating mean, variance and third central moment
+  of both the number of steps and the number of activations before
+  stabilization, on a fixed graph or on a fresh random graph per replica.
+- `Experiment` high-level API with cartesian-product sweeps, campaign
+  addition, light matplotlib plotting, CSV export, and fits of the
+  results (weighted least squares, test for a hidden term, recovery of
+  exact fractions).
+- Exact stabilization time of the conflict-guard rule under the random
+  central daemon, from three independent sources: the peak oracle, which
+  samples it without running the dynamics (`tinto.oracle`), exact
+  enumeration on small graphs (`tinto.exact`) and closed forms
+  (`tinto.theory`).
+- Companion notebooks that check the numerical statements of the papers.
+- 100% branch-covered by doctest-based examples.
+
+## Quickstart
+
+Install Tinto:
+
+```console
+$ pip install tinto
+```
+
+### Low-level API
+
+Drive one trajectory on a line graph:
+
+```pycon
+>>> from tinto import graphs, configs, schedulers, solvers, runners
+>>> from tinto.io import set_seed
+>>> set_seed(0)
+>>> Config = configs.make()
+>>> c = Config(graphs.line(20))
+>>> sched = schedulers.shuffled()(c)
+>>> solver = solvers.make()
+>>> steps, activations = runners.simple(c, sched, solver)
+>>> steps > 0
+True
+>>> c.total
+0
+```
+
+Or Monte-Carlo the moments of both metrics over many replicas:
+
+```pycon
+>>> from tinto import starters
+>>> set_seed(0)
+>>> starter = starters.from_graph(Config)(graphs.line(20))
+>>> res = runners.mc(starter, schedulers.shuffled(), solver, n_trials=20)
+>>> mean, var, m3 = res["steps"]
+>>> mean > 0
+True
+```
+
+### High-level API
+
+The `Experiment` class bundles a sweep + the Monte-Carlo runner + plot
+and export helpers. Define an `Iterator` over one parameter, wrap it in
+an `Experiment`, run:
+
+```pycon
+>>> from tinto import Experiment, Iterator
+>>> def build_starter(n):
+...     return starters.from_graph(Config)(graphs.line(n))
+>>> n_iter = Iterator("starter", [10, 20, 50], name="n", process=build_starter)
+>>> exp = Experiment(
+...     "line-sweep",
+...     iterator=n_iter,
+...     scheduler=schedulers.shuffled(),
+...     solver=solver,
+...     n_trials=50,
+... )
+>>> _ = exp.run(progress=False)
+>>> exp.results["line-sweep"]["axes"]
+('starter',)
+```
+
+Compose cartesian products with `*` and combine multiple campaigns with
+`+`:
+
+```pycon
+>>> kind_iter = Iterator("starter", ["random", "mono"], name="kind")
+>>> # plot or export via exp.plot(x="n", hue="kind") / exp.to_csv(...)
+```
+
+## Credits
+
+This package was created with [Cookiecutter][CC] and the [Package Helper 3][PH3] project template.
+
+[CC]: <https://github.com/audreyr/cookiecutter>
+[PH3]: <https://balouf.github.io/package-helper-3/>

tinto-0.1.0/.gitignore

@@ -0,0 +1,137 @@
+# build outputs
+*.pdf
+
+# python
+__pycache__/
+*.pyc
+.ipynb_checkpoints/
+
+# editors and OS
+.DS_Store
+Thumbs.db
+
+# ---- Python package (from the tinto repository) ----
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+# ruff
+.ruff_cache/
+
+# Coverage HTML output
+cov/
+
+# IDE settings
+.vscode/
+
+# PyCharm project settings
+.idea
+.claude
+
+# Local experiments
+sandbox/
+
+# Notebook / doctest artifacts
+schedulers.csv
+
+# Work clones of tools/publish.py
+.publish/

tinto-0.1.0/AUTHORS.md

@@ -0,0 +1,9 @@
+# Credits
+
+## Development Lead
+
+- Fabien Mathieu <fabien.mathieu@normalesup.org>
+
+## Contributors
+
+None yet. Why not be the first?

tinto-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,101 @@
+# Contributing
+
+Contributions are welcome, and they are greatly appreciated! Every little bit
+helps, and credit will always be given.
+
+You can contribute in many ways:
+
+## Types of Contributions
+
+### Report Bugs
+
+Report bugs at https://github.com/balouf/tinto/issues.
+
+If you are reporting a bug, please include:
+
+- Your operating system name and version.
+- Any details about your local setup that might be helpful in troubleshooting.
+- Detailed steps to reproduce the bug.
+
+### Fix Bugs
+
+Look through the GitHub issues for bugs. Anything tagged with "bug" and "help
+wanted" is open to whoever wants to implement it.
+
+### Implement Features
+
+Look through the GitHub issues for features. Anything tagged with "enhancement"
+and "help wanted" is open to whoever wants to implement it.
+
+### Write Documentation
+
+Tinto could always use more documentation, whether as part of the
+official Tinto docs, in docstrings, or even on the web in blog posts,
+articles, and such.
+
+### Submit Feedback
+
+The best way to send feedback is to file an issue at https://github.com/balouf/tinto/issues.
+
+If you are proposing a feature:
+
+- Explain in detail how it would work.
+- Keep the scope as narrow as possible, to make it easier to implement.
+- Remember that this is a volunteer-driven project, and that contributions
+  are welcome :)
+
+## Get Started!
+
+Ready to contribute? Here's how to set up `tinto` for local development.
+
+1. Fork the `tinto` repo on GitHub.
+
+2. Clone your fork locally::
+    ```console
+    $ git clone git@github.com:your_name_here/tinto.git
+    ```
+
+3. Install your local copy into a virtualenv. Assuming you have uv installed, this is how you set up your fork for local development:
+    ```console
+    $ cd tinto/
+    $ uv sync --all-extras
+    ```
+
+4. Create a branch for local development::
+    ```console
+    $ git checkout -b name-of-your-bugfix-or-feature
+    ```
+    Now you can make your changes locally.
+
+5. When you're done making changes, check that your changes pass the
+   tests:
+    ```console
+    $ uv run pytest
+    ```
+
+6. Commit your changes and push your branch to GitHub::
+    ```bash
+    $ git add .
+    $ git commit -m "Your detailed description of your changes."
+    $ git push origin name-of-your-bugfix-or-feature
+    ```
+
+7. Submit a pull request through the GitHub website.
+
+## Pull Request Guidelines
+
+Before you submit a pull request, check that it meets these guidelines:
+
+1. The pull request should include tests.
+2. If the pull request adds functionality, the docs should be updated. Put
+   your new functionality into a function with a docstring, and add the
+   feature to the list in `.github/README.md` or `HISTORY.md`.
+3. The pull request should work for Python for the versions supported by the package (ideally, the three latest minor CPython versions).
+   Make sure that the tests pass for all supported Python versions.
+
+## Tips
+
+To run a subset of tests:
+```bash
+$ uv run pytest tests.test_tinto
+```

tinto-0.1.0/HISTORY.md

@@ -0,0 +1,100 @@
+# History
+
+## 0.1.0 (2026-11-11): First release
+
+- First release on PyPI.
+
+### Coloring dynamics
+
+- `graphs`: a Numba-compiled CSR graph, the `line` and `ring` builders,
+  and three random generators, each with its edge-list variant: uniform
+  labeled tree (`cayley`), Erdős-Rényi `G(n, p)` drawn by geometric
+  skipping in O(n + m) (`erdos_renyi`), and bipartite `G(n1, n2, p)`
+  (`bipartite`). Graphs are also built from an edge list
+  (`edges_to_graph`) or an adjacency matrix (`adja_to_graph`).
+- `guards`: four enabling rules, from the default `color_clash` (a node
+  shares its color with a neighbor) to `color_clash_tie`, `color_min`
+  and `color_min_tie`.
+- `configs.make`: the coloring configuration, which keeps the set of
+  enabled nodes in sync with the colors. Initial colorings may use fewer
+  colors than the palette (`Config.color_randomize(k_init)`); without an
+  explicit palette, it has `max(k_init, Delta + 1)` colors.
+- `starters`: initial configurations, either on a fixed graph
+  (`from_graph`, uniform or random coloring) or on a fresh random graph
+  per draw (`from_cayley`, `from_erdos_renyi`, `from_bipartite`); every
+  starter takes a palette size `k` and a number of initial colors
+  `k_init`.
+- `schedulers`: `shuffled`, `ordered`, `bernoulli` and `independent`.
+- `solvers.make`, with five colorers: `colorer_lowest`, `colorer_next`
+  and `colorer_random` pick a free color (smallest, next, uniform);
+  `colorer_random_blind` and `colorer_next_blind` skip the neighborhood
+  scan and may leave clashes behind, modelling agents that detect a
+  conflict locally without seeing which colors are free.
+- `runners`: `simple` runs one trajectory and returns its numbers of
+  steps and activations (recolorings); `mc` runs replicas in parallel
+  and returns the mean, variance and third central moment of both.
+- The factories are memoized: two calls with the same arguments return
+  the same compiled object, so parameter sweeps compile each variant
+  once.
+- `io.set_seed` seeds every random generator, Numba's included.
+
+### Experiments and estimation
+
+- `tinto.Experiment`, `tinto.Iterator` and `tinto.ProductIterator`:
+  parameter sweeps (cartesian products with `*`, campaigns merged with
+  `+`), with `.run()`, `.plot()`, `.fit()`, `.fit_fractions()`,
+  `.report()`, `.residuals()`, `.to_dict()` and `.to_csv()`.
+- `estimate`: weighted least squares on a linear basis (`wls`, `fit`),
+  a likelihood-ratio test for a hidden term (`test_extra_term`), and the
+  recovery of exact fractions from fitted coefficients (`simplest_in`,
+  `recover`, `fit_fractions`, `fractions_table`).
+
+### Exact stabilization time
+
+Three independent sources for the stabilization time of the
+conflict-guard rule under the random central daemon:
+
+- `oracle`, the peak oracle: by the reduction lemma, `T = n - S` with `S`
+  the number of peaks of a uniform labeling, so `T` is sampled without
+  running the dynamics. `count_peaks`, and parallel samplers on a fixed
+  graph (`sample_graph`) or on a fresh random graph per trial
+  (`sample_erdos_renyi`, `sample_bipartite`, `sample_cayley`); the
+  samples depend on the seed only, not on the number of threads.
+- `exact`: the exact law of the peak count on small graphs, by
+  enumeration of all labelings and colorings (`peaks_distribution`,
+  colorings up to a permutation of the colors, optional split on whether
+  two nodes share their color, optional fixed labeling), its factorial
+  moments, and the enumeration of all labeled trees and all graphs on
+  `n` nodes.
+- `theory`: closed forms, one submodule per family:
+  - `general`: exact mean and variance on any graph (Theorems 1 and 3)
+    in rational arithmetic, the mean from a fixed initial coloring, and
+    a compiled floating-point monochrome variance for loops over
+    millions of graphs;
+  - `path_cycle`: generating functions in exact integers, exact laws and
+    closed forms;
+  - `erdos_renyi`: exact moments and fixed-`p` limit law;
+  - `bipartite`: monochrome law and limit mean;
+  - `cayley`: pair-degree laws, asymptotic variance slope and the
+    generating function of the law on the uniform labeled tree;
+  - `star`: law, mean and variance of the star, the graph of largest
+    variance.
+
+  `theory` imports nothing from the simulation side, nor from `exact`;
+  `tests/test_independence.py` enforces it.
+
+### Documentation
+
+- Numpydoc docstrings with doctests on every public module, class and
+  function; 100% branch coverage under `NUMBA_DISABLE_JIT=1`.
+- Sphinx reference pages for every module.
+- Two tutorials: `introduction`, a tour of the modules with a
+  `verbose_run` helper that walks one step at a time through the
+  dynamics, and `basics`, a first set of experiments.
+- Companion notebooks, starting with
+  `docs/companion/exact_stabilization_time.ipynb`: the numerical
+  statements of the exact stabilization-time report, each checked by
+  confronting closed forms, exact enumeration and Monte Carlo (sympy is
+  in the `dev` group for its symbolic sections). Notebooks that assert
+  checks are stored without outputs; the docs workflow executes them
+  before building, so a failing check fails the build.

tinto-0.1.0/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.5
+Name: tinto
+Version: 0.1.0
+Summary: How long does a self-stabilizing graph coloring take to settle? Tinto measures it with a Numba-compiled Monte Carlo over pluggable graphs, guards, schedulers and recoloring rules, down to the variance and skewness of the stabilization time. For the conflict-guard rule under the random central daemon, it also provides exact results.
+Project-URL: Repository, https://github.com/balouf/tinto
+Project-URL: Documentation, https://balouf.github.io/tinto
+Author-email: Fabien Mathieu <fabien.mathieu@normalesup.org>
+Maintainer-email: Fabien Mathieu <fabien.mathieu@normalesup.org>
+License-Expression: MIT
+License-File: AUTHORS.md
+Requires-Python: >=3.10
+Requires-Dist: numba>=0.65.0
+Requires-Dist: scipy>=1.15.3
+Description-Content-Type: text/markdown
+
+# <img src="../docs/_static/logo.svg" alt="Tinto logo" width="48" valign="middle" /> Tinto
+
+
+[![PyPI Status](https://img.shields.io/pypi/v/tinto.svg)](https://pypi.python.org/pypi/tinto)
+[![Build Status](https://github.com/balouf/tinto/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/balouf/tinto/actions?query=workflow%3Abuild)
+[![Documentation Status](https://github.com/balouf/tinto/actions/workflows/docs.yml/badge.svg?branch=main)](https://github.com/balouf/tinto/actions?query=workflow%3Adocs)
+[![License: MIT](https://img.shields.io/badge/license-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code Coverage](https://codecov.io/gh/balouf/tinto/branch/main/graphs/badge.svg)](https://codecov.io/gh/balouf/tinto/tree/main)
+
+How long does a self-stabilizing graph coloring take to settle? Tinto measures it with a Numba-compiled Monte Carlo over pluggable graphs, guards, schedulers and recoloring rules, down to the variance and skewness of the stabilization time. For the conflict-guard rule under the random central daemon, it also provides exact results.
+
+
+- Free software: MIT
+- Documentation: <https://balouf.github.io/tinto/>.
+- Github: <https://github.com/balouf/tinto>
+
+
+## Features
+
+- Numba-compiled dynamics: CSR graphs (line, ring, uniform labeled tree,
+  Erdős-Rényi `G(n, p)`, bipartite `G(n1, n2, p)`), pluggable guards,
+  four schedulers (shuffled, ordered, Bernoulli, independent) and five
+  colorers (lowest, next or uniform free color, plus two blind variants
+  that may leave clashes behind).
+- Monte-Carlo driver aggregating mean, variance and third central moment
+  of both the number of steps and the number of activations before
+  stabilization, on a fixed graph or on a fresh random graph per replica.
+- `Experiment` high-level API with cartesian-product sweeps, campaign
+  addition, light matplotlib plotting, CSV export, and fits of the
+  results (weighted least squares, test for a hidden term, recovery of
+  exact fractions).
+- Exact stabilization time of the conflict-guard rule under the random
+  central daemon, from three independent sources: the peak oracle, which
+  samples it without running the dynamics (`tinto.oracle`), exact
+  enumeration on small graphs (`tinto.exact`) and closed forms
+  (`tinto.theory`).
+- Companion notebooks that check the numerical statements of the papers.
+- 100% branch-covered by doctest-based examples.
+
+## Quickstart
+
+Install Tinto:
+
+```console
+$ pip install tinto
+```
+
+### Low-level API
+
+Drive one trajectory on a line graph:
+
+```pycon
+>>> from tinto import graphs, configs, schedulers, solvers, runners
+>>> from tinto.io import set_seed
+>>> set_seed(0)
+>>> Config = configs.make()
+>>> c = Config(graphs.line(20))
+>>> sched = schedulers.shuffled()(c)
+>>> solver = solvers.make()
+>>> steps, activations = runners.simple(c, sched, solver)
+>>> steps > 0
+True
+>>> c.total
+0
+```
+
+Or Monte-Carlo the moments of both metrics over many replicas:
+
+```pycon
+>>> from tinto import starters
+>>> set_seed(0)
+>>> starter = starters.from_graph(Config)(graphs.line(20))
+>>> res = runners.mc(starter, schedulers.shuffled(), solver, n_trials=20)
+>>> mean, var, m3 = res["steps"]
+>>> mean > 0
+True
+```
+
+### High-level API
+
+The `Experiment` class bundles a sweep + the Monte-Carlo runner + plot
+and export helpers. Define an `Iterator` over one parameter, wrap it in
+an `Experiment`, run:
+
+```pycon
+>>> from tinto import Experiment, Iterator
+>>> def build_starter(n):
+...     return starters.from_graph(Config)(graphs.line(n))
+>>> n_iter = Iterator("starter", [10, 20, 50], name="n", process=build_starter)
+>>> exp = Experiment(
+...     "line-sweep",
+...     iterator=n_iter,
+...     scheduler=schedulers.shuffled(),
+...     solver=solver,
+...     n_trials=50,
+... )
+>>> _ = exp.run(progress=False)
+>>> exp.results["line-sweep"]["axes"]
+('starter',)
+```
+
+Compose cartesian products with `*` and combine multiple campaigns with
+`+`:
+
+```pycon
+>>> kind_iter = Iterator("starter", ["random", "mono"], name="kind")
+>>> # plot or export via exp.plot(x="n", hue="kind") / exp.to_csv(...)
+```
+
+## Credits
+
+This package was created with [Cookiecutter][CC] and the [Package Helper 3][PH3] project template.
+
+[CC]: <https://github.com/audreyr/cookiecutter>
+[PH3]: <https://balouf.github.io/package-helper-3/>

tinto-0.1.0/citation.cff

@@ -0,0 +1,17 @@
+
+cff-version: 1.2.0
+title: Tinto
+message: >-
+  If you use this software, please cite it using the
+  metadata from this file.
+type: software
+version: 0.1.0
+date-released: "2026-11-11"
+authors:
+  - family-names: Mathieu
+    given-names: Fabien
+    email: fabien.mathieu@normalesup.org
+repository-code: "https://github.com/balouf/tinto/"
+url: "https://balouf.github.io/tinto/"
+abstract: "How long does a self-stabilizing graph coloring take to settle? Tinto measures it with a Numba-compiled Monte Carlo over pluggable graphs, guards, schedulers and recoloring rules, down to the variance and skewness of the stabilization time. For the conflict-guard rule under the random central daemon, it also provides exact results."
+license: MIT

tinto-0.1.0/conftest.py

@@ -0,0 +1,20 @@
+"""Pytest configuration for the Tinto test suite."""
+
+import os
+
+# Disable numba JIT so that coverage can instrument the bodies of @jitclass /
+# @njit functions. Must be set before numba is imported — conftest.py runs
+# before any test or project module. CI mirrors this via the NUMBA_DISABLE_JIT
+# env var in .github/workflows/build.yml.
+os.environ.setdefault("NUMBA_DISABLE_JIT", "1")
+
+# Headless matplotlib backend for .plot() doctests. Must be set before any
+# matplotlib import; MPLBACKEND is the official env var for that.
+os.environ.setdefault("MPLBACKEND", "Agg")
+
+import numpy as np
+
+# NumPy 2.0 changed scalar repr: np.int32(2) now prints as "np.int32(2)"
+# instead of "2", which breaks doctests that were written against JIT output
+# (plain Python ints). The legacy="1.25" flag restores the old repr.
+np.set_printoptions(legacy="1.25")

tinto-0.1.0/docs/_static/logo.svg

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" role="img" aria-label="Tinto logo: 5-cycle with a valid 3-coloring">
+  <title>Tinto</title>
+  <!-- Pentagon (5-cycle) with a proper 3-coloring: R, G, B, R, G. -->
+  <!-- Vertex positions, regular pentagon centered at (50, 50), radius 35. -->
+  <g stroke="#2f3437" stroke-width="3" stroke-linecap="round">
+    <line x1="50"   y1="15"   x2="16.7" y2="39.2"/>
+    <line x1="16.7" y1="39.2" x2="29.4" y2="78.3"/>
+    <line x1="29.4" y1="78.3" x2="70.6" y2="78.3"/>
+    <line x1="70.6" y1="78.3" x2="83.3" y2="39.2"/>
+    <line x1="83.3" y1="39.2" x2="50"   y2="15"/>
+  </g>
+  <g stroke="#2f3437" stroke-width="2.5">
+    <circle cx="50"   cy="15"   r="11" fill="#d62728"/>
+    <circle cx="16.7" cy="39.2" r="11" fill="#2ca02c"/>
+    <circle cx="29.4" cy="78.3" r="11" fill="#1f77b4"/>
+    <circle cx="70.6" cy="78.3" r="11" fill="#d62728"/>
+    <circle cx="83.3" cy="39.2" r="11" fill="#2ca02c"/>
+  </g>
+</svg>