CoolPlot 1.0.0__tar.gz → 1.2.0__tar.gz

{coolplot-1.0.0/src/CoolPlot.egg-info → coolplot-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CoolPlot
-Version: 1.0.0
+Version: 1.2.0
 Summary: Thermodynamic property diagrams with CoolProp as data source.
 Author-email: Jorrit Wronski <coolplot@jorrit.org>
 License: MIT License 
@@ -19,14 +19,14 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Visualization
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.22

{coolplot-1.0.0 → coolplot-1.2.0}/pyproject.toml

@@ -9,7 +9,7 @@ description = "Thermodynamic property diagrams with CoolProp as data source."
 readme = "README.md"
 license = {file = "LICENSE"}
 authors = [{name = "Jorrit Wronski", email = "coolplot@jorrit.org"}]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 dependencies = [
     "numpy>=1.22",
     "coolprop>=8.0",
@@ -20,11 +20,11 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Topic :: Scientific/Engineering :: Physics",
     "Topic :: Scientific/Engineering :: Visualization",
 ]

{coolplot-1.0.0 → coolplot-1.2.0/src/CoolPlot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CoolPlot
-Version: 1.0.0
+Version: 1.2.0
 Summary: Thermodynamic property diagrams with CoolProp as data source.
 Author-email: Jorrit Wronski <coolplot@jorrit.org>
 License: MIT License 
@@ -19,14 +19,14 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Visualization
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.22

{coolplot-1.0.0 → coolplot-1.2.0}/src/CoolPlot.egg-info/SOURCES.txt

@@ -16,25 +16,31 @@ src/coolplot/interaction.py
 src/coolplot/psychrometric.py
 src/coolplot/scene.py
 src/coolplot/compose/__init__.py
+src/coolplot/compose/branding.py
 src/coolplot/compose/builder.py
+src/coolplot/compose/corners.py
 src/coolplot/compose/layout.py
+src/coolplot/compose/rails.py
 src/coolplot/core/__init__.py
 src/coolplot/core/cycle.py
 src/coolplot/core/diagram_type.py
 src/coolplot/core/errors.py
 src/coolplot/core/events.py
 src/coolplot/core/floats.py
+src/coolplot/core/images.py
 src/coolplot/core/implementation.py
 src/coolplot/core/limits.py
 src/coolplot/core/numbers.py
 src/coolplot/core/quantities.py
 src/coolplot/core/state.py
+src/coolplot/core/textwidth.py
 src/coolplot/core/units.py
 src/coolplot/engine/__init__.py
 src/coolplot/engine/background.py
 src/coolplot/engine/cache.py
 src/coolplot/engine/engine.py
 src/coolplot/engine/planning.py
+src/coolplot/engine/store.py
 src/coolplot/render/__init__.py
 src/coolplot/render/base.py
 src/coolplot/render/mpl.py
@@ -62,6 +68,7 @@ src/coolplot/thermo/limits.py
 src/coolplot/thermo/native.py
 src/coolplot/thermo/process.py
 src/coolplot/thermo/provider.py
+src/coolplot/thermo/references.py
 src/coolplot/thermo/stepping.py
 src/coolplot/thermo/tracer.py
 src/coolplot/thermo/cycles/__init__.py
@@ -71,7 +78,9 @@ tests/test_api_vocabulary.py
 tests/test_architecture.py
 tests/test_backend_conformance.py
 tests/test_background.py
+tests/test_branding.py
 tests/test_contracts.py
+tests/test_curve_store.py
 tests/test_cycles.py
 tests/test_diagram.py
 tests/test_engine.py
@@ -84,6 +93,8 @@ tests/test_numerics.py
 tests/test_pdf.py
 tests/test_plotly.py
 tests/test_psychro.py
+tests/test_rails.py
+tests/test_saturation_anchors.py
 tests/test_scene_js.py
 tests/test_scene_render.py
 tests/test_spec.py

{coolplot-1.0.0 → coolplot-1.2.0}/src/coolplot/__init__.py

@@ -42,6 +42,7 @@ _LAZY = {
     "CalcSettings": ".spec",
     "LabelSettings": ".spec",
     "PageSettings": ".spec",
+    "BrandingSettings": ".spec",
     "Engine": ".engine",
     "Fluid": ".thermo",
     "DiagramType": ".core.diagram_type",

{coolplot-1.0.0 → coolplot-1.2.0}/src/coolplot/__version__.py

@@ -1,4 +1,4 @@
 # CoolPlot version information
-VERSION = (1, 0, 0, '')
+VERSION = (1, 2, 0, '')
 
 __version__ = '.'.join(map(str, VERSION[:3])) + ''.join(VERSION[3:])

{coolplot-1.0.0 → coolplot-1.2.0}/src/coolplot/chart.py

@@ -46,13 +46,15 @@ from .compose import compose
 from .core.cycle import Cycle, StateInput
 from .core.errors import PropertyError
 from .core.quantities import quantity_key
-from .core.state import StatePoint
+from .core.state import StatePoint, with_mollier_temperature
 from .core.units import get_unit_system
 from .engine import BackgroundEngine, CurveCache, Engine, plan
 from .scene import Scene
-from .spec import CycleSpec, DiagramSpec, IsolineSet, get_settings
+from .spec import CycleSpec, DiagramSpec, IsolineSet, SaturationAnchor, get_settings
+from .spec.diagram import ANCHOR_KEYS
 from .style.theme import Theme, get_theme
 from .style.values import LineStyle, MarkerStyle
+from .thermo.cycles.paths import resolve_state
 
 
 def _known_key(name, inputs):
@@ -135,6 +137,9 @@ def check_state(state: StatePoint, provider) -> StatePoint:
     """
     if "v" not in state and "rho" in state and provider.kind == "fluid" and state.rho > 0.0:
         state = StatePoint(v=1.0 / state.rho, **state.to_dict())
+    if provider.kind == "humid_air":
+        # A humid-air state made before 1.2 lacks the temperature scale of the Mollier chart
+        state = with_mollier_temperature(state)
     missing = [k for k in provider.quantities if k not in state]
     if missing:
         raise ValueError("The state {0} is not a state of {1}: it lacks {2}.".format(state, provider.name, missing))
@@ -205,6 +210,7 @@ class Chart:
             self.engine = Engine(cache)
         self.scene = Scene()
         self._default_renderer = None
+        self._file_renderer = None   # the matplotlib renderer of save(), outside pyplot
         self._plot_size_pt = None
         try:
             check_fluid(self.engine, spec.fluid)   # a misspelt fluid fails here, not at the first draw
@@ -306,6 +312,22 @@ class Chart:
     def theme(self, value):
         self.settings = self.spec.settings.with_(look=get_theme(value))
 
+    @property
+    def show_saturation(self):
+        """Whether the saturation curve is drawn whatever lines are set.
+
+        True by default: the quality lines 0 and 1 of a fluid with a
+        critical point, or the line of 100 % relative humidity, are drawn
+        even when the lines set leave them out, or are not set at all.
+        False hides the curve; None leaves it to the values of the quality
+        or humidity lines (a chart saved before 1.2).
+        """
+        return self.spec.show_saturation
+
+    @show_saturation.setter
+    def show_saturation(self, value):
+        self.spec = self.spec.with_(show_saturation=value)
+
     @property
     def title(self) -> str:
         """The title shown above the chart."""
@@ -358,7 +380,7 @@ class Chart:
     # Content
     # ------------------------------------------------------------------
     def set_lines(self, key: str, values=None, num: int = None, range=None, rounding: bool = None,
-                  labels: bool = None, points: int = None, units=None):
+                  labels: bool = None, points: int = None, units=None, at_saturation=None):
         """Add or replace the family of lines of constant ``key``.
 
         Parameters
@@ -366,7 +388,8 @@ class Chart:
         key : str
             Quantity held constant: "T", "p", "h", "s", "rho", "u" or "Q"
             in a property diagram; "RH", "Twb", "h" or "v" in a
-            psychrometric chart.
+            psychrometric chart, and also "T" (isotherms) in a Mollier
+            h,x chart.
         values : sequence, optional
             Explicit constant values, in the chart's units or in ``units``.
         num : int, optional
@@ -388,7 +411,27 @@ class Chart:
         points : int, optional
             Points per line; default from ``settings.calc``.
         units : str or UnitSystem, optional
-            Units of ``values`` and ``range``; default the chart's units.
+            Units of ``values``, ``range`` and ``at_saturation``; default the
+            chart's units.
+        at_saturation : dict, optional
+            Place the lines through saturation states at even steps instead
+            of giving values: ``{"T": 10}`` puts a line through the saturated
+            vapour every 10 K of saturation temperature (in deg C charts at
+            0, 10, 20 deg C), ``{"p": 2}`` every 2 bar of saturation
+            pressure. ``"Q": 0`` uses the saturated liquid (the bubble point
+            of a blend) instead of the vapour (the dew point), and
+            ``"range": (lo, hi)`` limits the saturation temperatures or
+            pressures. Steps and range are in ``units``. The labels show the
+            lines' own values ("s=2.321 kJ/kg/K"); ``"label": "saturation"``
+            shows the saturation state instead ("T_sat=0 deg C"). Charts of
+            a fluid only.
+
+        Examples
+        --------
+        Isentropes through the saturated vapour every 10 K, as compressor
+        lines read off at round evaporating temperatures:
+
+        >>> diagram.set_lines("s", at_saturation={"T": 10}, labels=True)   # doctest: +SKIP
         """
         key = quantity_key(key)
         family = self._family(key)
@@ -404,9 +447,43 @@ class Chart:
             _checked_range(family, label, range_SI)
         if num is None:
             num = family.default_num
-        self.spec = self.spec.with_isolines(IsolineSet(key, values_SI, num, range_SI, rounding, points, labels))
+        anchor = None
+        if at_saturation is not None:
+            if values is not None or range is not None:
+                raise ValueError("Give the lines either values or a range, or at_saturation, not both; a range "
+                                 "of saturation states goes into at_saturation as 'range'.")
+            anchor = self._saturation_anchor(at_saturation, units)
+        spec = self.spec.with_isolines(IsolineSet(key, values_SI, num, range_SI, rounding, points, labels, anchor))
+        if anchor is not None:
+            # Place the lines now, so a step that is too small or a fluid
+            # without a saturation curve is reported here, not at the next draw
+            self.engine.domain(spec)
+        self.spec = spec
         return key
 
+    def _saturation_anchor(self, at_saturation, units) -> SaturationAnchor:
+        """A SaturationAnchor from set_lines(at_saturation=...), converted from ``units`` to SI."""
+        if isinstance(at_saturation, SaturationAnchor):
+            return at_saturation
+        given = dict(at_saturation)
+        span = given.pop("range", None)
+        label = given.pop("label", "value")
+        qualities = [given.pop(name) for name in ("Q", "x", "q") if name in given]   # written as the labels write it
+        if len(qualities) > 1:
+            raise ValueError("Give the vapour quality of the saturation states once, as 'Q' or 'x'.")
+        Q = float(qualities[0]) if qualities else 1.0
+        if len(given) != 1:
+            raise ValueError("at_saturation takes one step, by saturation temperature or pressure, e.g. "
+                             "{{'T': 10}} or {{'p': 2, 'Q': 0}}, not {0}.".format(at_saturation))
+        (by, step), = given.items()
+        by = quantity_key(by)
+        if by not in ANCHOR_KEYS:
+            raise ValueError("Lines are placed by saturation temperature 'T' or pressure 'p', not '{0}'.".format(by))
+        unit = self._units(units)[by]
+        step_SI = float(step) / abs(unit.scale)   # a difference: the scale only, no offset
+        span_SI = None if span is None else tuple(float(v) for v in unit.to_SI(span))
+        return SaturationAnchor(by, step_SI, Q, span_SI, label)
+
     def _family(self, key: str):
         """The line family of a quantity in this chart, or ValueError."""
         family = self.spec.diagram.family(key)
@@ -454,7 +531,7 @@ class Chart:
 
     def add_cycle(self, name, states=None, loops=None, paths=None, numbers: bool = True, units=None,
                   line_style: LineStyle = None, marker_style: MarkerStyle = None, steps: int = 20,
-                  closed: bool = True, **arrays):
+                  closed: bool = True, labels=None, **arrays):
         """Add or replace a cycle, drawn on top of the chart.
 
         Parameters
@@ -492,6 +569,11 @@ class Chart:
             Segments per drawn path.
         closed : bool
             Whether the default loop returns to the first state.
+        labels : dict, optional
+            ``{number: text}``: a text written next to a state, after its
+            number, e.g. ``{2: "ADP 11.2 deg C", 3: "+8.1 kJ/kg"}`` shows
+            "2: ADP 11.2 deg C". With ``numbers=False`` the text stands
+            alone and states without a label get nothing.
         **arrays
             Instead of ``states``: arrays of two properties, e.g.
             ``add_cycle("measured", p=[...], h=[...])``.
@@ -503,17 +585,18 @@ class Chart:
         cycle = name if isinstance(name, Cycle) else (states if isinstance(states, Cycle) else None)
         if cycle is not None:
             spec = self._spec_from_model(cycle, None if isinstance(name, Cycle) else name, loops, paths, numbers,
-                                         line_style, marker_style, steps)
+                                         line_style, marker_style, steps, labels)
         else:
             unit_system = self._units(units)
             inputs = self._state_inputs(_states_from_arrays(states, arrays) if arrays else states, name, unit_system)
             spec = CycleSpec(str(name), inputs, loops or _default_loops(inputs, closed), paths or (), numbers,
-                             line_style, marker_style, steps)
+                             line_style, marker_style, steps, () if labels is None else labels)
         self._compute_cycle(spec)   # compute now, so that errors show up here
         self.spec = self.spec.with_cycle(spec)
         return spec.name
 
-    def _spec_from_model(self, cycle: Cycle, name, loops, paths, numbers, line_style, marker_style, steps):
+    def _spec_from_model(self, cycle: Cycle, name, loops, paths, numbers, line_style, marker_style, steps,
+                         labels=None):
         """A CycleSpec for a computed Cycle, after checking that it belongs to this chart's fluid."""
         if cycle.fluid and self._other_fluid(cycle.fluid):
             raise ValueError("Cycle '{0}' was computed for {1}, but this chart shows {2}.".format(
@@ -521,7 +604,8 @@ class Chart:
         states = tuple((n, check_state(state, self.fluid)) for n, state in cycle.states)
         cycle = replace(cycle, states=states)   # with v filled in for a cycle computed before 0.7
         return CycleSpec.from_cycle(cycle, name=name, loops=loops, paths=paths, numbers=numbers,
-                                    line_style=line_style, marker_style=marker_style, steps=steps)
+                                    line_style=line_style, marker_style=marker_style, steps=steps,
+                                    labels=labels)
 
     def _state_inputs(self, states, name, unit_system):
         """(number, StateInput) pairs from a list (numbered from 1) or a dict of given states."""
@@ -592,6 +676,24 @@ class Chart:
             return {n: states[n].in_units(unit_system) for n in sorted(states)}
         return {n: states[n] for n in sorted(states)}
 
+    def state(self, entry, units=None) -> StatePoint:
+        """The full state (SI units) from two properties in the chart's units or in ``units``.
+
+        ``entry`` is a dict as for a state of :meth:`add_cycle`, e.g.
+        ``chart.state({"T": 13, "RH": 95})`` on a psychrometric chart in
+        engineering units, or a StatePoint (returned as it is, after a
+        check that it belongs to this chart). A "via" needs a state before
+        it and is not accepted here.
+        """
+        given = state_input(entry, self._units(units), self.fluid)
+        if given.via is not None:
+            raise ValueError("A state with via '{0}' needs a state before it; give two properties.".format(
+                given.via))
+        try:
+            return resolve_state(self.fluid, given)
+        except PropertyError as e:
+            raise self._in_units(e) from None
+
     # ------------------------------------------------------------------
     # Interaction helpers
     # ------------------------------------------------------------------
@@ -629,7 +731,8 @@ class Chart:
         curves = self.engine.curves(spec, domain, plan(spec, domain))
         previous = {item.id: item for item in self.scene if item.role == "isoline_label"}
         cycles = [self.engine.cycle(spec, c) for c in spec.cycles]
-        items, axes = compose(spec, domain, curves, self._plot_size_pt, previous, cycles)
+        items, axes = compose(spec, domain, curves, self._plot_size_pt, previous, cycles,
+                              self.engine.source_lines(spec))
         self.scene.replace_all(items, axes=axes)
         return self.scene
 
@@ -662,18 +765,20 @@ class Chart:
         """Let background work finish before a script draws: previews first,
         then the final curves they make room for. Warns, instead of waiting
         for ever, when nothing finishes any more."""
-        last = None
         for _ in range(10):
+            # Counted from before the scene: a job can end while the scene is
+            # built (a crashed process pool fails all of its jobs at once), and
+            # the retries it queues next only end in the wait after that scene
+            finished = self.engine.finished_jobs
             self.update_scene()
             ready, needed = self.engine.progress
             if not self.engine.busy and ready >= needed:   # a failed line may still be due a retry
                 return
-            if self.engine.finished_jobs == last:   # the last wait finished no job at all
+            self.wait()
+            if self.engine.finished_jobs == finished:   # neither the scene nor the wait finished a job
                 warnings.warn("Background work makes no progress, the drawing may be incomplete.",
                               UserWarning, stacklevel=3)
                 return
-            last = self.engine.finished_jobs
-            self.wait()
         warnings.warn("Background work did not finish, the drawing may be incomplete (is the cache "
                       "smaller than the number of lines?).", UserWarning, stacklevel=3)
 
@@ -687,21 +792,62 @@ class Chart:
         ``.svg`` is written by the SVG writer and ``.html`` by the web
         renderer (a static page), neither of which needs matplotlib;
         every other extension (PNG, PDF, EPS, ...) goes through matplotlib,
-        with ``kwargs`` such as ``dpi`` or ``pdf_fonts`` passed on. The
-        canvas has the size of ``settings.page`` for every writer, unless
-        ``width`` and ``height`` (pixels) are given for SVG or HTML.
+        with ``kwargs`` such as ``dpi`` or ``pdf_fonts`` passed on.
+
+        An SVG file has the size of ``settings.page``, stated in points
+        (``width``, ``height`` and ``unit`` passed as ``kwargs`` override
+        it). Matplotlib files are drawn into a figure of their own outside
+        pyplot, of the size of ``settings.page``, so that saving charts in
+        a server or a loop does not collect pyplot figures; after
+        :meth:`draw` or :meth:`show` made a figure, that figure is saved
+        instead, at its own size. An HTML page has the size of
+        ``settings.page`` in pixels, unless ``width`` and ``height`` are given.
         """
         extension = str(path).rsplit(".", 1)[-1].lower() if "." in str(path) else ""
-        if extension in ("svg", "html", "htm"):
-            from .render.svg import PX_PER_PT
-            page = self.spec.settings.page
-            kwargs.setdefault("width", round(page.width_pt * PX_PER_PT))
-            kwargs.setdefault("height", round(page.height_pt * PX_PER_PT))
+        page = self.spec.settings.page
         if extension == "svg":
-            from .render.svg import SvgRenderer
-            self.draw(SvgRenderer(**kwargs)).save(path)
+            from .render.svg import PX_PER_PT, SvgRenderer
+            options = dict(width=page.width_pt * PX_PER_PT, height=page.height_pt * PX_PER_PT, unit="pt")
+            options.update(kwargs)
+            self.draw(SvgRenderer(**options)).save(path)
         elif extension in ("html", "htm"):
+            from .render.svg import PX_PER_PT
             from .render.web import WebRenderer
+            kwargs.setdefault("width", round(page.width_pt * PX_PER_PT))
+            kwargs.setdefault("height", round(page.height_pt * PX_PER_PT))
             self.draw(WebRenderer(**kwargs)).save(path)
-        else:
+        elif self._default_renderer is not None:
             self.draw().save(path, **kwargs)
+        else:
+            self.draw(self._matplotlib_file_renderer()).save(path, **kwargs)
+
+    def _matplotlib_file_renderer(self):
+        """The renderer of :meth:`save` for matplotlib formats: a figure outside pyplot, sized by settings.page."""
+        size = self.spec.settings.page.size_in
+        if self._file_renderer is None:
+            from .render.mpl import MatplotlibRenderer
+            self._file_renderer = MatplotlibRenderer(use_pyplot=False, figsize=size)
+        elif tuple(self._file_renderer.figure.get_size_inches()) != tuple(size):
+            self._file_renderer.figure.set_size_inches(size)   # the page settings changed since
+        return self._file_renderer
+
+    def uncached_curves(self) -> int:
+        """How many isolines of the chart are in neither part of the curve cache.
+
+        Lines in memory or in the cache's folder on disk (see
+        :class:`coolplot.engine.CurveCache`) do not count; looking for one
+        on disk loads it into memory, as the next update would. The answer
+        costs the calculation region of the chart (the T-p box and, for
+        mixtures, the phase envelope), which the next update needs anyway,
+        but no line is calculated. An application can use it to tell a
+        request that only draws from one that calculates.
+
+        It counts the final lines of the isoline families only: cycles are
+        left out, and with a background engine a line counts until its
+        final version is in the cache, also while a job for it is running.
+        """
+        spec = self.spec
+        domain = self.engine.domain(spec)
+        cache = self.engine.cache
+        return sum(1 for request in plan(spec, domain)
+                   if cache.peek(self.engine.cache_key(spec, domain, request)) is None)

{coolplot-1.0.0 → coolplot-1.2.0}/src/coolplot/compose/__init__.py

@@ -14,14 +14,17 @@ from .builder import compose as compose_python, label_text, scaled_theme
 __all__ = ["compose", "compose_python", "label_text", "scaled_theme"]
 
 
-def compose(spec, domain, curves, plot_size_pt=None, previous_labels=None, cycles=None):
+def compose(spec, domain, curves, plot_size_pt=None, previous_labels=None, cycles=None, sources=()):
     """All scene items and the axes for a diagram, see :func:`coolplot.compose.builder.compose`.
 
     Composed by coolplot-core when it is installed and the native mode is
     "on" (see :func:`coolplot.corelib.enabled`), by the Python composer
-    otherwise; both give the same scene.
+    otherwise; both give the same scene. coolplot-core does not compose
+    the branding (badge and watermark), so a branded chart always takes
+    the Python composer.
     """
-    if corelib.enabled():
+    branding = spec.settings.branding
+    if corelib.enabled() and not (branding.has_badge or branding.watermark):
         try:
             result = corelib.compose(spec, domain, curves, plot_size_pt, previous_labels, cycles)
         except corelib.CoreRefusal as error:
@@ -32,4 +35,4 @@ def compose(spec, domain, curves, plot_size_pt=None, previous_labels=None, cycle
             result = None
         if result is not None:
             return result
-    return compose_python(spec, domain, curves, plot_size_pt, previous_labels, cycles)
+    return compose_python(spec, domain, curves, plot_size_pt, previous_labels, cycles, sources)

coolplot-1.2.0/src/coolplot/compose/branding.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+"""The badge and the watermark of a chart, from its branding settings.
+
+:func:`branding` turns :class:`coolplot.spec.settings.BrandingSettings`
+into the :class:`coolplot.scene.Badge` and :class:`coolplot.scene.Watermark`
+of the axes, sized in points for the plot area the labels are laid out
+for. The badge is made in the corner of the settings (the lower right
+one for "auto"); the composer then gives it its corner together with the
+legend
+(:func:`coolplot.compose.corners.place_corners`), so that an automatic
+one never takes the corner of the other, and isoline labels keep clear of
+both.
+"""
+from __future__ import annotations
+
+from typing import Optional, Sequence, Tuple
+
+from ..core.images import load_picture
+from ..scene import Badge, Watermark
+from ..spec.diagram import DiagramSpec
+from ..style.theme import Theme
+from ..style.values import Font, TextStyle
+from .layout import Frame
+
+#: The watermark is never taller than this fraction of the plot area.
+WATERMARK_MAX_HEIGHT = 0.8
+
+
+def branding(spec: DiagramSpec, theme: Theme, frame: Frame,
+             sources: Sequence[str] = ()) -> Tuple[Optional[Badge], Optional[Watermark]]:
+    """(badge, watermark) for the chart; None for what the settings do not ask for.
+
+    ``theme`` is the theme with the page's font scale applied and
+    ``frame`` the plot area the labels are laid out in. ``sources`` are
+    the lines naming the sources of the properties and the versions, from
+    :meth:`coolplot.engine.Engine.source_lines` (the composer does not ask
+    CoolProp itself); the badge shows them above ``BrandingSettings.lines``.
+    The badge sits in the corner of the settings, the lower right one for
+    "auto", until the composer places it.
+    """
+    settings = spec.settings.branding
+    watermark = None
+    if settings.watermark:
+        pictures = tuple(load_picture(s) for s in settings.watermark)
+        width = settings.watermark_width * frame.width_pt
+        if width * pictures[0].aspect > WATERMARK_MAX_HEIGHT * frame.height_pt:
+            width = WATERMARK_MAX_HEIGHT * frame.height_pt / pictures[0].aspect
+        if width > 0.0:
+            watermark = Watermark(picture=pictures, width_pt=width, opacity=settings.watermark_opacity)
+    if not settings.has_badge:
+        return None, watermark
+    axes_style = theme.axes
+    font_scale = spec.settings.page.font_scale
+    text = TextStyle(font=Font(family=axes_style.tick_label.font.family, size_pt=settings.font_size_pt * font_scale),
+                     color=axes_style.tick_label.color or "#000000", h_align="left", v_align="bottom")
+    location = "lower right" if settings.location == "auto" else settings.location
+    badge = Badge(location=location, logo=tuple(load_picture(s) for s in settings.logo),
+                  logo_width_pt=settings.logo_width_pt, lines=tuple(sources) + settings.lines, text=text,
+                  background=axes_style.background or "#ffffff", background_alpha=settings.background_alpha,
+                  frame_color=axes_style.frame_color if settings.frame else None)
+    if badge.empty:
+        return None, watermark
+    return badge, watermark