Persistent (or "memory", "label") cycler

[mfitzp]

When the original proposal for the Cycler was made I put together an implementation of a "persistent cycler" that used the same back-end but provided an interface whereby values were provided in exchange for a key (label). The first time a value is requested the next value in the cycler is returned while on subsequent calls the same result will be returned for the same key.

The use case was for consistent labeling of plots throughout an analysis. When performing initial analysis it's often not important what the styles used are, but it is helpful if they stay the same.

I imagine implementing this as a subclass of Cycler with a .get() accessor (similar to a dictionary) or perhaps as a simple class that contains a cycler object within. This might put it out of scope of this project. It would be nice (long term) to be able to pass these cyclers into matplotlib functions and have styles assigned automatically (and in the case of the persistent cycler on the basis of labels).

If this seems reasonable I can open a couple of PRs with alternate implementations for discussion.

[tacaswell]

I like it. I would lean towards a 'has a' rather than a 'is a' relationship

Marrying this with https://github.com/Nikea/history would also be interesting.

[edited to finish my sentence]

[tacaswell]

from itertools import cycle


class RememberTheStyle():
    def __init__(self, sty_cylr, cache=None, loop=False):
        """Persistent style by key

        This is a class for easily managing consistent style across for
        classes of data across many plots.

        The first time you use `rts[key]` it gets the next style dictionary from
        it's internal `Cycler`.  Subsequent calls to `rts[key]` will return the
        same dictionary.

        Parameters
        ----------
        sty_cylr : Cycler
            Anything that yields dictionaries when iterated over

        cache : dict-like or None, optional
           MuttableMapping to use as the internal key -> style cache


        """
        if cache is None:
            cache = {}

        self._cache = cache
        if loop:
            self._style_cycler = cycle(sty_cylr)
        else:
            self._style_cycler = iter(sty_cylr)

    @property
    def style_cache(self):
        return self._cache

    def __getitem__(self, key):
        try:
            return dict(self.style_cache[key])
        except KeyError:
            # pass instead of handling in here to make stack trace
            # nicer
            pass
        try:
            new_style = next(self._style_cycler)
        except StopIteration:
            raise RuntimeError("Asked for more style than we have")

        self._cache[key] = dict(new_style)
        return dict(new_style)

@WeatherGod @efiring Should this go in this repo, or in it's own?

• this repo: pro cool feature, con: feature creep
• it's own repo: pro now feature creep, con: repo will have more boiler plate than code

[tacaswell]

Eh, this is too cool not put someplace and on consideration my worry about feature creep is less annoying than the thought of all the boiler plate needed for another project.

[danielballan]

+1 I like that I can pass in History for the cache.

[danielballan]

Name ideas: TaggedStyles, StyleTags, StyleLib, StyleCache, NamedStyles

[ericdill]

Could call it Styler