scistackplot 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -16,10 +16,13 @@ is a new leaf, not a redesign.
16
16
 
17
17
  from __future__ import annotations
18
18
 
19
- from dataclasses import dataclass, field
19
+ import hashlib
20
+ import pickle
21
+ from dataclasses import dataclass, field, fields
20
22
  from typing import Any
21
23
 
22
24
  import pandas as pd
25
+ from scistacklog import Log
23
26
 
24
27
  from ..text.aliases import DisplayText
25
28
  from ..text.colors import MarkColors
@@ -212,6 +215,12 @@ class Panel:
212
215
  return " · ".join(str(v) for v in self.key.values())
213
216
 
214
217
 
218
+ #: Fields ``ResolvedPlot.layout_key`` leaves out (its docstring says why each).
219
+ _LAYOUT_KEY_SKIPPED = frozenset({"auto_text", "reduction", "custom", "difference_siblings"})
220
+ #: Reasons a layout key could not be taken, WARNed once each.
221
+ _LAYOUT_KEY_FAILURES: set[str] = set()
222
+
223
+
215
224
  @dataclass
216
225
  class ResolvedPlot:
217
226
  """
@@ -388,6 +397,64 @@ class ResolvedPlot:
388
397
  #: plotted" button, its popup and the optional footnote read this.
389
398
  omissions: Any = None
390
399
 
400
+ def layout_key(self) -> str | None:
401
+ """A digest of everything a layout of this figure reads, or None when
402
+ one cannot be taken (then nothing is cached: the old behaviour).
403
+
404
+ The ONE owner of "same layout". ``autosize.settle`` (the chosen text
405
+ size) and ``render.mpl.layout_decisions`` (the export's decisions)
406
+ key their caches on it, so the two cannot disagree about when a
407
+ figure is the same.
408
+
409
+ Why content, not ``id()``: a GUI request rebuilds the figure from the
410
+ plan cache every time, so an ``id()`` key never matched across
411
+ requests, and an identical request ran the whole auto-size search
412
+ again (scistack-debug.log 2026-11-03: 22 s after a plan-cache HIT).
413
+
414
+ Why a digest of EVERY field rather than a list of the fields thought
415
+ to move text: a hand-picked list is a second owner of "what a layout
416
+ reads" and goes stale when a field is added. A digest of everything
417
+ can only miss too often (a colour change re-lays out), never hit
418
+ wrongly.
419
+
420
+ Left out, each for a stated reason:
421
+ ``auto_text``: a layout reads only its ``reference`` (added back);
422
+ ``reduction``: renderers never read it;
423
+ ``custom``: the user's function is not called by an auto-size trial
424
+ (``custom.measuring``), and ``layout_decisions`` never caches a
425
+ custom kind;
426
+ ``difference_siblings``: enter through their own keys.
427
+ """
428
+ try:
429
+ siblings = []
430
+ for sibling in self.difference_siblings:
431
+ key = sibling.layout_key()
432
+ if key is None:
433
+ return None
434
+ siblings.append(key)
435
+ state = [
436
+ (f.name, getattr(self, f.name))
437
+ for f in fields(self)
438
+ if f.name not in _LAYOUT_KEY_SKIPPED
439
+ ]
440
+ state.append(("auto_reference", getattr(self.auto_text, "reference", None)))
441
+ state.append(("difference_siblings", siblings))
442
+ blob = pickle.dumps(state, protocol=pickle.HIGHEST_PROTOCOL)
443
+ except Exception as exc: # noqa: BLE001 — reported, and only disables caching
444
+ reason = f"{type(exc).__name__}: {exc}"
445
+ if reason not in _LAYOUT_KEY_FAILURES:
446
+ _LAYOUT_KEY_FAILURES.add(reason)
447
+ # WARN once per reason: silently never caching IS the slow bug.
448
+ Log.warn(
449
+ "layout key: cannot digest %s figure (%s); its layouts are "
450
+ "not cached and every request lays it out again",
451
+ self.kind,
452
+ reason,
453
+ layer="scistackplot",
454
+ )
455
+ return None
456
+ return hashlib.blake2b(blob, digest_size=16).hexdigest()
457
+
391
458
  @property
392
459
  def figure_label(self) -> str:
393
460
  """Human-readable identifier for this figure within the fan-out."""
@@ -9,8 +9,10 @@ expected to reproduce.
9
9
 
10
10
  from __future__ import annotations
11
11
 
12
+ import copy
12
13
  import threading
13
14
  import time
15
+ from collections import OrderedDict
14
16
  from contextlib import contextmanager
15
17
  from dataclasses import dataclass, field, replace
16
18
  from typing import Any
@@ -19,6 +21,7 @@ import numpy as np
19
21
  import pandas as pd
20
22
  from scistacklog import Log
21
23
 
24
+ from ..text.autosize import clear_memo as clear_auto_size_memo
22
25
  from ..text.figsize import aspect_name
23
26
  from ..reduce.resolved import (
24
27
  GRID_COLUMN_FACTOR,
@@ -1467,30 +1470,44 @@ def _fit_x_labels(fig, labelled: list[Any], resolved: ResolvedPlot, rect) -> Non
1467
1470
  ticks = _collect_x_ticks(labelled, resolved)
1468
1471
  if not ticks:
1469
1472
  return
1470
- fit, rows = _fit_x_ticks(fig, ticks, resolved)
1471
- _apply_x_fit(ticks, fit)
1472
- fig.tight_layout(rect=rect)
1473
- refit, rows = _fit_x_ticks(fig, ticks, resolved)
1474
- if not _same_decision(fit, refit):
1475
- Log.debug("x tick labels refitted after layout: %s", refit.describe(), layer=LAYER)
1476
- _apply_x_fit(ticks, refit)
1477
- fig.tight_layout(rect=rect)
1478
- fit = refit
1479
- _log_fit("x tick labels", fit, rows, _text_measure(fig))
1480
- drawn = _draw_x_groups(fig, ticks, resolved)
1481
- brackets, geometry = drawn if drawn is not None else (None, None)
1482
- if drawn is not None:
1483
- fig.tight_layout(rect=rect)
1484
- # The decisions travel with the Figure, so a caller (a test today, the
1485
- # GUI's "labels still overlap" notice later) can read what was decided
1486
- # instead of re-deriving it from the drawing.
1487
- setattr(
1488
- fig,
1489
- LABEL_FIT_ATTR,
1490
- {"ticks": fit, "brackets": brackets, "bracket_geometry": geometry},
1491
- )
1492
- if fit.fits:
1493
- _verify_x_ticks(fig, ticks, fit)
1473
+ positions = sum(len(t.labels) for t in ticks)
1474
+ # Phases, because this is the largest phase of render_mpl on a crowded
1475
+ # axis (scistack-debug.log 2026-11-03: 1.7-2.4 s of a 4.3 s layout at 105
1476
+ # positions) and which of the fits, layouts or brackets costs it was
1477
+ # unknown. Each tight_layout is its own phase.
1478
+ with Log.timer("fit_x_labels", layer=LAYER, extra=f"{positions} label(s)") as timer:
1479
+ with timer.phase("fit"):
1480
+ fit, rows = _fit_x_ticks(fig, ticks, resolved)
1481
+ _apply_x_fit(ticks, fit)
1482
+ with timer.phase("tight_layout_after_fit"):
1483
+ fig.tight_layout(rect=rect)
1484
+ with timer.phase("refit"):
1485
+ refit, rows = _fit_x_ticks(fig, ticks, resolved)
1486
+ if not _same_decision(fit, refit):
1487
+ Log.debug("x tick labels refitted after layout: %s", refit.describe(), layer=LAYER)
1488
+ with timer.phase("tight_layout_after_refit"):
1489
+ _apply_x_fit(ticks, refit)
1490
+ fig.tight_layout(rect=rect)
1491
+ fit = refit
1492
+ with timer.phase("log_fit"):
1493
+ _log_fit("x tick labels", fit, rows, _text_measure(fig))
1494
+ with timer.phase("draw_brackets"):
1495
+ drawn = _draw_x_groups(fig, ticks, resolved)
1496
+ brackets, geometry = drawn if drawn is not None else (None, None)
1497
+ if drawn is not None:
1498
+ with timer.phase("tight_layout_after_brackets"):
1499
+ fig.tight_layout(rect=rect)
1500
+ # The decisions travel with the Figure, so a caller (a test today, the
1501
+ # GUI's "labels still overlap" notice later) can read what was decided
1502
+ # instead of re-deriving it from the drawing.
1503
+ setattr(
1504
+ fig,
1505
+ LABEL_FIT_ATTR,
1506
+ {"ticks": fit, "brackets": brackets, "bracket_geometry": geometry},
1507
+ )
1508
+ if fit.fits:
1509
+ with timer.phase("verify"):
1510
+ _verify_x_ticks(fig, ticks, fit)
1494
1511
 
1495
1512
 
1496
1513
  # ---------------------------------------------------------------------------
@@ -2436,6 +2453,27 @@ def _apply_difference_bars(panel_axes, placement, resolved: ResolvedPlot, sizes)
2436
2453
  # The decisions, for a renderer that cannot measure text (the plotly preview)
2437
2454
 
2438
2455
 
2456
+ #: ``(resolved.layout_key(), width_in, height_in)`` -> ``layout_decisions``
2457
+ #: output. A GUI request rebuilds an equal figure from the plan cache every
2458
+ #: time, and laying it out again cost the whole auto-size search (22 s on a
2459
+ #: 105-position bar chart, scistack-debug.log 2026-11-03). Stored and
2460
+ #: returned as deep copies, so a caller cannot change what the next one
2461
+ #: gets. A custom kind is never cached: its decisions come from a draw that
2462
+ #: calls the user's function, whose code can change under the same data.
2463
+ _DECISIONS: "OrderedDict[tuple, dict]" = OrderedDict()
2464
+ _DECISIONS_SIZE = 32
2465
+
2466
+
2467
+ def clear_layout_caches() -> None:
2468
+ """Forget every cached layout: ``layout_decisions``' decisions and
2469
+ ``autosize.settle``'s chosen sizes. For tests that patch the renderer and
2470
+ count what it draws; nothing in the product needs it (the keys are
2471
+ content, so a changed figure never hits)."""
2472
+ with _MPL_LOCK:
2473
+ _DECISIONS.clear()
2474
+ clear_auto_size_memo()
2475
+
2476
+
2439
2477
  def layout_decisions(
2440
2478
  resolved: ResolvedPlot,
2441
2479
  *,
@@ -2471,7 +2509,32 @@ def layout_decisions(
2471
2509
  height = float(height_in or style.height)
2472
2510
  with _one_figure_at_a_time("layout_decisions"), Log.timer(
2473
2511
  "layout_decisions", layer=LAYER, extra=f"{width:.2f}x{height:.2f}in"
2474
- ):
2512
+ ) as timer:
2513
+ # A phase of its own: the digest pickles every panel frame, and its
2514
+ # cost must stay visible next to the layouts it saves.
2515
+ with timer.phase("layout_key"):
2516
+ content = resolved.layout_key() if resolved.kind is not PlotKind.CUSTOM else None
2517
+ cache_key = (content, width, height) if content is not None else None
2518
+ cached = _DECISIONS.get(cache_key) if cache_key is not None else None
2519
+ if content is not None and cache_key is not None and cached is not None:
2520
+ _DECISIONS.move_to_end(cache_key)
2521
+ Log.info(
2522
+ "layout_decisions%s: reused the layout of an identical figure "
2523
+ "(content %s at %.2fx%.2fin); no matplotlib layout",
2524
+ f" ({resolved.figure_label})" if resolved.figure_label else "",
2525
+ content[:8],
2526
+ width,
2527
+ height,
2528
+ layer=LAYER,
2529
+ )
2530
+ return copy.deepcopy(cached)
2531
+ Log.debug(
2532
+ "layout_decisions: %s",
2533
+ f"not cached yet (content {content[:8]})" if content is not None
2534
+ else "custom kind, never cached" if resolved.kind is PlotKind.CUSTOM
2535
+ else "no layout key, not cached",
2536
+ layer=LAYER,
2537
+ )
2475
2538
  # {reference: decisions} of each auto-size trial laid out here.
2476
2539
  trials: dict[float, dict] = {}
2477
2540
 
@@ -2483,8 +2546,9 @@ def layout_decisions(
2483
2546
 
2484
2547
  reusable = resolved.kind is not PlotKind.CUSTOM
2485
2548
  # Auto text is chosen at the size being decided (the pane's, in Fit
2486
- # pane), keyed on the caller's object so the preview's later
2487
- # render_plotly and a Save of the same resolve reuse it.
2549
+ # pane), keyed on the figure's content (ResolvedPlot.layout_key) so
2550
+ # the preview's later render_plotly, a Save of the same resolve and
2551
+ # the next request's equal figure reuse it.
2488
2552
  target = at_size(
2489
2553
  settle(
2490
2554
  resolved,
@@ -2521,7 +2585,7 @@ def layout_decisions(
2521
2585
  decisions = _figure_decisions(fig)
2522
2586
  finally:
2523
2587
  plt.close(fig)
2524
- return {
2588
+ result = {
2525
2589
  **decisions,
2526
2590
  # autosize.AutoTextSize, or None when the size is fixed: the
2527
2591
  # preview draws at these sizes rather than searching again.
@@ -2529,6 +2593,11 @@ def layout_decisions(
2529
2593
  "width_in": width,
2530
2594
  "height_in": height,
2531
2595
  }
2596
+ if cache_key is not None:
2597
+ _DECISIONS[cache_key] = copy.deepcopy(result)
2598
+ while len(_DECISIONS) > _DECISIONS_SIZE:
2599
+ _DECISIONS.popitem(last=False)
2600
+ return result
2532
2601
 
2533
2602
 
2534
2603
  def _figure_decisions(fig) -> dict:
@@ -2573,33 +2642,39 @@ def _layout_report(resolved: ResolvedPlot, *, decisions_out: dict | None = None)
2573
2642
  from ..text.autosize import LayoutReport
2574
2643
  from ..export.custom import measuring
2575
2644
 
2576
- # A custom figure's marks do not move the labels measured here, so a
2577
- # trial layout does not call the user's function (custom.measuring).
2578
- with measuring():
2579
- fig = render(resolved)
2580
- try:
2581
- if decisions_out is not None:
2582
- decisions_out.update(_figure_decisions(fig))
2583
- fits = getattr(fig, LABEL_FIT_ATTR, None) or {}
2584
- ticks, brackets = fits.get("ticks"), fits.get("brackets")
2585
- legend = getattr(fig, LEGEND_ATTR, None) or {}
2586
- reach = getattr(fig, GRID_REACH_ATTR, None)
2587
- by_element, unattributed = _overflow_by_element(fig)
2588
- rules = _tick_and_title_rules(fig)
2589
- return LayoutReport(
2590
- tick_steps=tuple(ticks.steps) if ticks is not None else (),
2591
- ticks_fit=ticks.fits if ticks is not None else True,
2592
- bracket_steps=tuple(brackets.steps) if brackets is not None else (),
2593
- brackets_fit=brackets.fits if brackets is not None else True,
2594
- legend_steps=tuple(legend.get("steps", ())),
2595
- left_overlap_pt=reach.left_overlap_pt if reach is not None else 0.0,
2596
- below_overlap_pt=reach.below_overlap_pt if reach is not None else 0.0,
2597
- overflow_by_element=by_element,
2598
- unattributed_overflow_in=unattributed,
2599
- **rules,
2600
- )
2601
- finally:
2602
- plt.close(fig)
2645
+ # Phases: one auto-size trial = render + these reads, and the ~0.4-0.6 s
2646
+ # between render_mpl's TOTAL and the trial's own time was unaccounted for
2647
+ # (scistack-debug.log 2026-11-03).
2648
+ with Log.timer("layout_report", layer=LAYER, extra=str(resolved.kind)) as timer:
2649
+ # A custom figure's marks do not move the labels measured here, so a
2650
+ # trial layout does not call the user's function (custom.measuring).
2651
+ with timer.phase("render"), measuring():
2652
+ fig = render(resolved)
2653
+ try:
2654
+ if decisions_out is not None:
2655
+ decisions_out.update(_figure_decisions(fig))
2656
+ fits = getattr(fig, LABEL_FIT_ATTR, None) or {}
2657
+ ticks, brackets = fits.get("ticks"), fits.get("brackets")
2658
+ legend = getattr(fig, LEGEND_ATTR, None) or {}
2659
+ reach = getattr(fig, GRID_REACH_ATTR, None)
2660
+ with timer.phase("overflow_by_element"):
2661
+ by_element, unattributed = _overflow_by_element(fig)
2662
+ with timer.phase("tick_and_title_rules"):
2663
+ rules = _tick_and_title_rules(fig)
2664
+ return LayoutReport(
2665
+ tick_steps=tuple(ticks.steps) if ticks is not None else (),
2666
+ ticks_fit=ticks.fits if ticks is not None else True,
2667
+ bracket_steps=tuple(brackets.steps) if brackets is not None else (),
2668
+ brackets_fit=brackets.fits if brackets is not None else True,
2669
+ legend_steps=tuple(legend.get("steps", ())),
2670
+ left_overlap_pt=reach.left_overlap_pt if reach is not None else 0.0,
2671
+ below_overlap_pt=reach.below_overlap_pt if reach is not None else 0.0,
2672
+ overflow_by_element=by_element,
2673
+ unattributed_overflow_in=unattributed,
2674
+ **rules,
2675
+ )
2676
+ finally:
2677
+ plt.close(fig)
2603
2678
 
2604
2679
 
2605
2680
  #: Drawn tick labels may touch by this much (points) before they collide.
@@ -363,14 +363,22 @@ def is_auto(resolved: "ResolvedPlot") -> bool:
363
363
  return resolved.spec.style.text.base is None
364
364
 
365
365
 
366
- #: ``(id(resolved), width, height, text)`` -> ``(weakref(resolved), result)``.
366
+ #: ``(resolved.layout_key(), width, height, text)`` -> ``(weakref(resolved), result)``.
367
367
  #: One resolve is laid out by the preview's decisions, then drawn by plotly,
368
- #: then perhaps saved: the search runs once. The weak reference guards
369
- #: against a recycled id.
368
+ #: then perhaps saved, and the next GUI request rebuilds an EQUAL figure:
369
+ #: the search runs once for all of them. Keyed on content (the key's one
370
+ #: owner is ``ResolvedPlot.layout_key``); when no key can be taken it falls
371
+ #: back to ``("id", id(resolved))``, where the weak reference guards against
372
+ #: a recycled id.
370
373
  _MEMO: "OrderedDict[tuple, tuple]" = OrderedDict()
371
374
  _MEMO_SIZE = 32
372
375
 
373
376
 
377
+ def clear_memo() -> None:
378
+ """Forget every chosen size (``render.mpl.clear_layout_caches`` calls it)."""
379
+ _MEMO.clear()
380
+
381
+
374
382
  def settle(
375
383
  resolved: "ResolvedPlot",
376
384
  *,
@@ -393,11 +401,17 @@ def settle(
393
401
  style = resolved.spec.style
394
402
  width = float(width_in or style.width)
395
403
  height = float(height_in or style.height)
396
- key = (id(resolved), width, height, text)
404
+ content = resolved.layout_key()
405
+ key = (content if content is not None else ("id", id(resolved)), width, height, text)
397
406
  hit = _MEMO.get(key)
398
- if hit is not None and hit[0]() is resolved:
407
+ if hit is not None and (content is not None or hit[0]() is resolved):
399
408
  _MEMO.move_to_end(key)
400
- Log.debug("auto text size: reused (reference %gpt)", hit[1].reference, layer=LAYER)
409
+ Log.debug(
410
+ "auto text size: reused (reference %gpt, %s)",
411
+ hit[1].reference,
412
+ f"same content {content[:8]}" if content is not None else "same object",
413
+ layer=LAYER,
414
+ )
401
415
  return with_sizes(resolved, hit[1])
402
416
 
403
417
  if measure is None:
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.5
2
2
  Name: scistackplot
3
- Version: 0.2.2
3
+ Version: 0.2.3
4
4
  Summary: Spec-driven plotting for long-format scientific data — standalone, GUI-friendly
5
5
  Author: SciStack Contributors
6
6
  License-Expression: MIT
@@ -20,8 +20,8 @@ Requires-Python: >=3.10
20
20
  Requires-Dist: csv-stats>=0.5.0
21
21
  Requires-Dist: numpy>=1.21
22
22
  Requires-Dist: pandas>=1.5
23
- Requires-Dist: scicanonicalhash==0.2.2
24
- Requires-Dist: scistacklog==0.2.2
23
+ Requires-Dist: scicanonicalhash==0.2.3
24
+ Requires-Dist: scistacklog==0.2.3
25
25
  Provides-Extra: dev
26
26
  Requires-Dist: matplotlib>=3.6; extra == 'dev'
27
27
  Requires-Dist: plotly>=5.0; extra == 'dev'
@@ -31,7 +31,7 @@ scistackplot/reduce/panels.py,sha256=fPvzZQVVSRcY2ysRuMdah671LjsmrEQZFqtSwgTgyCI
31
31
  scistackplot/reduce/reducer.py,sha256=QIMfvCceadKA0II9fb0Gl9_BzkNbx7dVmQrY7NoCw1U,24737
32
32
  scistackplot/reduce/reduction.py,sha256=Gs6P2KmRTXTMzQwnEri-fYDhckJa-ZM_wjbdjEiFeno,14883
33
33
  scistackplot/reduce/resolve.py,sha256=XH9qWo6S8C50SIj1BwzQVzCcKVXp0GKlAWDlQ-1yoL4,149346
34
- scistackplot/reduce/resolved.py,sha256=jU3y2ssreIZcIh5RD4NFTY98VdeK95TPdyAeBsSQGJI,26860
34
+ scistackplot/reduce/resolved.py,sha256=7KpSsntP9qs9grLRAPCRAWLjj09Y47Rb8Zokw_aRob8,30018
35
35
  scistackplot/reduce/rows.py,sha256=-oGaDjpd-JFtnrhbTl1xD291tyLtgTCobZcXHnQVvc4,6767
36
36
  scistackplot/reduce/series_stats.py,sha256=xyMy68U_IwW7OgMl3TpcPjs36YTV5jfCdfP_ap3UMoQ,10811
37
37
  scistackplot/reduce/spaghetti.py,sha256=_4KoY7TLOELfBX70dnQwvf0jk4usINX1jPc_nwT6_t8,2904
@@ -43,7 +43,7 @@ scistackplot/reduce/weights.py,sha256=VJg7sPF-5JOAn9ny5ycC6WY8TtOYbk2Y2037prdvvr
43
43
  scistackplot/reduce/ylimits.py,sha256=RlD9vygeCpHMyXtmWMt3YAK8r4d0e2h6OB8BId1IwT0,35583
44
44
  scistackplot/render/__init__.py,sha256=bRNsabcoVBj9vwvwbJRFjY-sT_ni3MJ6lKkYpf6xfa8,1351
45
45
  scistackplot/render/base.py,sha256=q0fpxU06nndFybrs_ObHUN0izn6X0fijrGAA4QZ5AmE,53691
46
- scistackplot/render/mpl.py,sha256=1AcyF1E9mktc5_IwkxcrZw0QaLcxyuSJxSlEwSQk4LQ,116004
46
+ scistackplot/render/mpl.py,sha256=rT3q2U4e25pP9J4_2Hw4BpJIqZMEEt5u__A8h3WvZqQ,120088
47
47
  scistackplot/render/plotly_.py,sha256=15IiX2bDWIbrOKtHsLvVr3iFnGOf90W413Cj2Le31s0,95001
48
48
  scistackplot/sources/__init__.py,sha256=hIxs-P4pr0y_e_4dZQ7O_zPvrAszHd-OdW3BNqSfdQE,269
49
49
  scistackplot/sources/base.py,sha256=E575iODZbGfYxofzd2BayDMBFOaBUQP0dSJzWIwkh_8,21453
@@ -52,7 +52,7 @@ scistackplot/sources/dedup.py,sha256=vWEY_u8BxcXG0xvPyQmM0i1s86SEAFRN2otr95SzSAo
52
52
  scistackplot/sources/frame.py,sha256=780pKM_o2VwKqCbTBpQ4yXWbBXrHpBdcWGXW3UUAyBA,1270
53
53
  scistackplot/text/__init__.py,sha256=irnksxVrKdnrv4Bo18AHi9zoaLuJImOZSTIdBfqY9S8,97
54
54
  scistackplot/text/aliases.py,sha256=KUWWHyjZqwFIwAmJ0atdSukRuU9OMBfV1ljon6-ey4w,18083
55
- scistackplot/text/autosize.py,sha256=v8jf9eO--5F2qJaaeCgBAWGZCrAvNf5h-Q4RfW1xXNY,18906
55
+ scistackplot/text/autosize.py,sha256=TqO-04K0fkISgPtEb6V6XEwfP-QGEZimDR826T0kd1E,19505
56
56
  scistackplot/text/colors.py,sha256=88UEnGQeLUiYtsZnHF-8LiNAYpuWOzMamCz1BeYkz0E,13380
57
57
  scistackplot/text/figsize.py,sha256=NNb1r31rCydYJs7uiK1Jsrk--fNzVXiz-NtVm-iOz7k,4781
58
58
  scistackplot/text/framesize.py,sha256=7_L83HY14wLEpymK2fbro1pRG0aAwmV3NuzxGKQ0PzU,4123
@@ -60,6 +60,6 @@ scistackplot/text/paper.py,sha256=SeEbC0iOi3hvHHZoTdF77hVPgNWd5wH77igTZwD54kQ,75
60
60
  scistackplot/text/textsize.py,sha256=JfQq_e8VIkN61vif5KmVMAjtZRaxFT3SdfDXEhIyTDs,12093
61
61
  scistackplot/text/ticklabels.py,sha256=qn4A_0iza51Wja3tlez2nVED53S3qDUKIrLwdElVVlI,23412
62
62
  scistackplot/text/xaxis.py,sha256=v9XVra52lz30iJ-17_J382DB4v-TWv5H4_DgPQ5T1D0,7571
63
- scistackplot-0.2.2.dist-info/METADATA,sha256=aITRkEbRJctngWsIsBghEW7s0F--nhpwjDMfHrsvjwk,29547
64
- scistackplot-0.2.2.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
65
- scistackplot-0.2.2.dist-info/RECORD,,
63
+ scistackplot-0.2.3.dist-info/METADATA,sha256=hXHr8tKkx0DbptZBOQYTyCGIX9sQ33FwLS_2DZPOQvk,29547
64
+ scistackplot-0.2.3.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
65
+ scistackplot-0.2.3.dist-info/RECORD,,