Plots.jl: default font size too small on pyplot backend?

[floswald]

i just updated to matplotlib 2 and found that the default font on plots is very small. how can I change that?

pyplot()
Plots.PyPlotBackend()

julia> Plots.plot(rand(10),linewidth=2)

for comparison, calling PyPlot directly gives

julia> using PyPlot
julia> PyPlot.plot(rand(10),linewidth=2)

[ma-laforge]

Just as a comment:

• The default font sizes generated by Plots.jl using pyplot() is not meant to match the ones generated directly by using PyPlot.
• Instead, the font sizes should be calibrated approximately match irrespective of which backend you use (pyplot, gr, plotly, pgfplots, inspectdr, ...)

If you don't like the current size of your plots, you can scale all of the defaults using the solution developed here https://github.com/JuliaPlots/Plots.jl/issues/560:

Plots.scalefontsizes(1.5) #Or some other factor

That will apply a *=1.5 to all of the font sizes.

Alternatively, you could use the following solution:

fnt = Plots.font("Helvetica", 10.0)
default(titlefont=fnt, guidefont=fnt, tickfont=fnt, legendfont=fnt)

[floswald]

Ok I see! Thanks!

On Sat, 18 Mar 2017 at 23:27, ma-laforge [e-mail] wrote:

Just as a comment:

• The default font sizes generated by Plots.jl using pyplot() is not
  meant to match the ones generated directly by using PyPlot.
• Instead, the font sizes should be calibrated approximately match
  irrespective of which backend you use (pyplot, gr, plotly, pgfplots,
  inspectdr, ...)

If you don't like the current size of your plots, you can scale all of the
defaults using the solution developed here #560
https://github.com/JuliaPlots/Plots.jl/issues/560:

Plots.scalefontsizes(1.5) #Or some other factor

That will apply a *=1.5 to all of the font sizes.

Alternatively, you could use the following solution:

fnt = Plots.font("Helvetica", 10.0)
default(titlefont=fnt, guidefont=fnt, tickfont=fnt, legendfont=fnt)

—
You are receiving this because you authored the thread.
Reply to this email directly, view it on GitHub
https://github.com/JuliaPlots/Plots.jl/issues/739#issuecomment-287579438,
or mute the thread
https://github.com/notifications/unsubscribe-auth/AA-Wdgnga_uFTz4S1K5txiF_4XStzMKzks5rnFpIgaJpZM4MhaQH
.

[mkborregaard]

I still think that we should adjust the standard font sizes in the pyplot backend after that updated to matplotlib 2.0. It is an open question how to do it (i.e. should default dpi be changed) - but @ma-laforge is on the case https://github.com/JuliaPlots/Plots.jl/issues/733

[mkborregaard]

But pyplot doesn't look quite as small on my computer (as you can see on #733 )

[floswald]

That's of course saying much better what I meant.
+1

On Sun, 19 Mar 2017 at 08:30, Michael Krabbe Borregaard <
[email protected]> wrote:

I still think that we should adjust the standard font sizes in the pyplot
backend after that updated to matplotlib 2.0. It is an open question how to
do it (i.e. should default dpi be changed) - but @ma-laforge
https://github.com/ma-laforge is on the case #733
https://github.com/JuliaPlots/Plots.jl/issues/733

—
You are receiving this because you authored the thread.
Reply to this email directly, view it on GitHub
https://github.com/JuliaPlots/Plots.jl/issues/739#issuecomment-287599857,
or mute the thread
https://github.com/notifications/unsubscribe-auth/AA-WdhL9deFvg6CtELJ7SyGkCYUZRGTiks5rnNmdgaJpZM4MhaQH
.

[floswald]

True it does not! Your version is almost ok for me.

On Sun, 19 Mar 2017 at 08:35, Michael Krabbe Borregaard <
[email protected]> wrote:

But pyplot doesn't look quite as small on my computer (as you can see on

733 https://github.com/JuliaPlots/Plots.jl/issues/733 )

—
You are receiving this because you authored the thread.
Reply to this email directly, view it on GitHub
https://github.com/JuliaPlots/Plots.jl/issues/739#issuecomment-287600014,
or mute the thread
https://github.com/notifications/unsubscribe-auth/AA-Wdh-WMp-lur-wY5zO8jQEdwW1kFPRks5rnNq8gaJpZM4MhaQH
.

[ma-laforge]

I thought the same at first... until I looked at your plot a bit closer @floswald.

Both plots are rendered using fonts that are 8 pixels high....

It's just that the one from @floswald is very large (1200x800)... So Github is resizing it to fit this thread - making the font look smaller.

PS - I re-opened a similar thread (https://github.com/JuliaPlots/Plots.jl/issues/741) hoping it will get a bit more attention. I also removed the part where you (@floswald) compare to using PyPlot directly - because that is not relevant to how Plots.jl works.

[ma-laforge]

@mkborregaard: I still think that we should adjust the standard font sizes in the pyplot backend after that updated to matplotlib 2.0. It is an open question how to do it (i.e. should default dpi be changed) - but @ma-laforge is on the case #733

Agreed. That's why I opened Issue https://github.com/JuliaPlots/Plots.jl/issues/741.

Edit: I don't think we should be changing the default DPI. I changed it from 100 down to 72 in PR https://github.com/JuliaPlots/Plots.jl/pull/740 - but that's because the 100 DPI constant appears to have been pulled out of the air. Setting DPI=72 allows 1 pixel to represent 1 point - a typical scheme.

Instead, I think we should be assuming most backends work @ 72 DPI - and make the default font size a bit larger... maybe 9 or 10 pixels high (font size of 9 or 10)?

[floswald]

Well not sure what to make of this...
The problem struck me when just looking at the pop up window that comes
out after calling plot. The fonts look good and readable in the PyPlot
window, they are hardly readable in the Plots window.
Is there any settings I should change or should I go with your suggestion
of directly setting the font size?
Thanks

On Sun, 19 Mar 2017 at 15:14, ma-laforge [e-mail] wrote:

I thought the same at first... until I looked at your plot a bit closer
@floswald https://github.com/floswald.

Both plots are rendered using fonts that are 8 pixels high....

It's just that the one from @floswald https://github.com/floswald is
very large (1200x800)... So Github is resizing it to fit this thread -
making the font look smaller.

—
You are receiving this because you were mentioned.

Reply to this email directly, view it on GitHub
https://github.com/JuliaPlots/Plots.jl/issues/739#issuecomment-287619486,
or mute the thread
https://github.com/notifications/unsubscribe-auth/AA-WduG2v72TAFvAGoO2d3b5G69RkyQzks5rnThWgaJpZM4MhaQH
.

[ma-laforge]

Sorry about that. I personally would not use scalefontsizes - because it keeps scaling up fonts each time it runs.

For now, I think your best option for now is to use the following pattern :

using Plots
fntsm = Plots.font("sans-serif", 10.0)
fntlg = Plots.font("sans-serif", 14.0)
default(titlefont=fntlg, guidefont=fntlg, tickfont=fntsm, legendfont=fntsm)

You would need to have this type of code whenever you use Plots.jl.
...I will try to find out if there is a better way.

[ma-laforge]

FYI @floswald:

Most defaults could be overwritten in a much cleaner fashion using the pattern shown in the documentation:

Plots.jl docs: Tip: You can override standard default values in your ~/.juliarc.jl file: PLOTS_DEFAULTS = Dict(:markersize => 10, :legend => false)

...But the solution I just gave you above require data structures that don't exist @ Julia startup - which means you must add it to every "script" you run.

The solution to this problem was proposed here by @tbreloff : https://github.com/JuliaPlots/Plots.jl/issues/555. We are just missing someone to figure out how to add in this new feature.

[ma-laforge]

If you are not up to it, I propose the following hack to make your life a bit easier:

1. Create your own Plots.jl wrapper module - and import it (ex: using PreConfiguredPlots)
2. Have that module simply import Plots, set the default font values, then return.

...Not ideal, but not a bad solution for the moment.

[mkborregaard]

@floswald Try instead just dpi = 150 or something like that.

[mkborregaard]

E.g.

pyplot()
# You don't need `Plots.PyPlotBackend()`

plot(rand(10),linewidth=2, dpi = 150) # and you don't need `Plots.`

Also, the gridlines look slightly nicer on Plots master.

[floswald]

yes!
thanks.

On 19 March 2017 at 21:30, Michael Krabbe Borregaard <
[email protected]> wrote:

E.g.

pyplot()

You don't need Plots.PyPlotBackend()

plot(rand(10),linewidth=2, dpi = 150) # and you don't need Plots.

—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
https://github.com/JuliaPlots/Plots.jl/issues/739#issuecomment-287645083,
or mute the thread
https://github.com/notifications/unsubscribe-auth/AA-Wdujy80E_HrwVHiv-WIHdM6jI_f68ks5rnZBsgaJpZM4MhaQH
.

[mkborregaard]

BTW you can set sessionwide defaults in the call to the backend, e.g. pyplot(dpi=150). I am not sure why your default size is so diffferent from mine, though. Would you mind trying Pkg.checkout("Plots")?

[floswald]

same on master for me:

julia> versioninfo()
Julia Version 0.5.0
Commit 3c9d753 (2016-09-19 18:14 UTC)
Platform Info:
  System: Darwin (x86_64-apple-darwin13.4.0)
  CPU: Intel(R) Core(TM) i7-4790K CPU @ 4.00GHz
  WORD_SIZE: 64
  BLAS: libopenblas (USE64BITINT DYNAMIC_ARCH NO_AFFINITY Haswell)
  LAPACK: libopenblas64_
  LIBM: libopenlibm
  LLVM: libLLVM-3.7.1 (ORCJIT, haswell)

[mkborregaard]

Thanks. Maybe a screen resolution thing?

[floswald]

tell me more about it? this happens on ca 1.5 year old macs with a retina
display. one's a laptop, other one's an iMac. what info could be useful?

On 20 March 2017 at 11:22, Michael Krabbe Borregaard <
[email protected]> wrote:

Thanks. Maybe a screen resolution thing?

—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
https://github.com/JuliaPlots/Plots.jl/issues/739#issuecomment-287720947,
or mute the thread
https://github.com/notifications/unsubscribe-auth/AA-Wdn8ynpMuSlqcLjUG9mGDW5EJxspHks5rnlNSgaJpZM4MhaQH
.

[mkborregaard]

a 1.5 year old macs with a retina display

That's what I have...

[ma-laforge]

@floswald , @mkborregaard : If I understand your current issue...

AFAIK: PyPlot ignores user-specified plot dimensions when displaying the GUI.

Instead, it Plots.jl just lets matplotlib do what it finds optimal - and lets users re-size the plot window however they prefer.

BTW: Macs seem to use very large toolbar buttons (w/h=75-80+ pixels?). That's alot of screen real-estate!.

[mkborregaard]

? No the pyplot backend respects size. WRT the toolbar buttons, retina screens use pixel doubling, so all gui elements use 4x the number of pixels (because the pixels are very small) (but this is off topic, sorry).

[ma-laforge]

@mkborregaard: You are correct - pyplot does respect size.

Sorry, I mis-read the code: Thought size was ignored on the GUI because it is not used by _create_backend_figure. - It still gets applied in _before_layout_calcs, though.

[ma-laforge]

@mkborregaard: WRT the toolbar buttons, retina screens use pixel doubling, so all gui elements use 4x the number of pixels (because the pixels are very small) (but this is off topic, sorry).

Not off-topic:

This explains the complaints of @floswald to me: a default font size of 8 pixels is a readable text size on most displays... but not on the retina screens - apparently.

Edit: ... Maybe dpi value used for screens should be machine-dependent (or at least user-configurable) instead of being set to 72 dpi (1 "point").

Also: I was stating this because the fonts look much smaller than 8 pixels on @floswald's attached image... but that's an optical illusion caused by the toolbar buttons being very large.

[floswald]

I am still a bit puzzled by what exactly you mean with all of this. All I am saying can be summarized in the attached picture: I do PyPlot.plot and the popup window shows a plot that is nice and readable. I do Plots.plot and I get very small fonts. I did not touch the windows, that's how they come out.

[ma-laforge]

My appologies for the noise: Most of the discussions around this issue were simply attempts to identify the root cause - and find a solution that will be more intuitive & easy to use.

I will try to provide a more structured answer:

1. You are correct. Plots.jl does not have font sizes/line withds that match PyPlot's defaults.
   a. But it is not not "wrong" to have different default sizes than PyPlot when using Plots.jl. The goal of Plots.jl is to allow you to switch between plotting packages (PyPlot being only one of many) - yet still get similar output. There should be nothing special about the PyPlot package defaults - even if you are using the pyplot backend.

Having said that...

1. You are correct: Plots.plot does give you output that is barely readable on your retina display.
   a. I strongly believe we should adress this issue.
   b. At the moment, we can only suggest a workaround for you (will recap below).
2. Unfortunately, the Plots.jl group has not agreed what to do about it (I am proposing solutions, along with others).

Workarounds

For now, we are proposing solutions that we don't necessarily feel ideal to us, but should work for you in the interim.

I myself have suggested for you to change the Plots.default values for font sizes:

#Insert following code after "using Plots":
fntsm = Plots.font("sans-serif", 10.0) #Try 20.0 or 40.0 if you like!
fntlg = Plots.font("sans-serif", 14.0) #Same
Plots.default(titlefont=fntlg, guidefont=fntlg, tickfont=fntsm, legendfont=fntsm)

...But you will still get razor-thin plot lines by default.

On the other hand, @mkborregaard suggested you change the default dpi setting:

#Insert following code after "using Plots":
Plots.default(dpi=150) #You could try 200, 225, 300, etc as well.

...But this might not affect both the line thickness & font sizes in a way you desire.

Having said that, I think one of these two solutions will probably have to do for now. You could find a combination of both that gets you the exact output you desire.

Please be aware: The output you have "tweaked" might look different in future releases if/when the Plots.jl group decides to address this issue.

[floswald]

Thanks for that answer, very clear. To exclude all misunderstanding, I am
very grateful for all that is Plots.jl, I think it's the right approach and
I use it both for work and for teaching. I know you guys do great work and
I thank you for it.

The purpose of my issue was just to raise some more awareness. We need
sensible defaults that look at least as pleasant as the plain vanilla
backend. 75% of students in my class have my type of computer. (I guess
retina screens are a big chunk of all screens out there.) I have a hard
time arguing for Plots.jl when it compares in this way to PyPlot. A
newcomer will not care or even want to know about @recipe or @layout,
but will seriously be put off by how Plots.plot(rand(10)) comes out right
now.

Good to know you are on the case!

cheers

[mkborregaard]

Agreed, the defaults should look good. I don't think the issue is the retina screen, as my defaults appear to be different, and I have a retina screen. It is a little puzzling - but it is almost certainly something to do with the compatibility with matplotlib 2.0.0.

[floswald]

Ok let me know if you need me to try something out or need more info!

On Tue, 21 Mar 2017 at 22:22, Michael Krabbe Borregaard <
[email protected]> wrote:

Agreed, the defaults should look good. I don't think the issue is the
retina screen, as my defaults appear to be different, and I have a retina
screen. It is a little puzzling - but it is almost certainly something to
do with the compatibility with matplotlib 2.0

—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
https://github.com/JuliaPlots/Plots.jl/issues/739#issuecomment-288223009,
or mute the thread
https://github.com/notifications/unsubscribe-auth/AA-Wdt9oC_IPhYUENmtjvqoz7HfcLKw-ks5roD-XgaJpZM4MhaQH
.

[mkborregaard]

The solution is to start by showing your students the plotlyjs backend :-)
plot(rand(10))

(kidding)

[ma-laforge]

All kidding aside: That is one of the powers of Plots.jl! If you are dissatisfied with the current output with a given backend - you can just try a different one while you wait for the bug fix.

For example: I did not explicitly account for the high pixel count of a retina display when I developed the inspectdr() backend.

..but it might be worth a try anyways: It is entirely possible that the Cairo or Gtk layers (GUI tools used to draw InspectDR plots) are already compensating for this "issue" on retina displays.

[ma-laforge]

@mkborregaard: I don't think the issue is the retina screen, as my defaults appear to be different, and I have a retina screen.

You might be right - very curious. I do have a couple of ideas:

Q1: Are you looking at the actual pyplot GUI - or just the .png output?

If you are looking at the .png output (say in IJulia, for example), then the image should look fine - because your web browser/image viewer will likely "scale up pixels" to make images "more reasonably sized".

Q2: Do macs have "compatibility modes" that would automatically "trick" the application (ie pyplot) into thinking that the screen resolution is actually lower than it really is?

Q3: Are you both using the same pyplot "backend"?

PyPlot itself allows you to select from multiple GUI backends as well: wxWidgets, Gtk, tk, Qt, ...

Other Comment
If you are concerned that @floswald 's output has larger dimensions than you expected: Might be possible that he maximized the window before taking a screenshot?

When one does this, you end up with a larger canvas size - but your font sizes & line widths stay the same.

Net effect: fonts look smaller relative to the (now larger) plot dimensions.

[mkborregaard]

Q1: The actual pyplot GUI (from the REPL).
Q2: Yes, the mac does this resolution reinterpretation automatically. Can you post how the default size looks on your screen?
Q3: The default – I’d assume that to be the same, but I don’t know how to check.
I don’t think @floswald changed the size of the window.

[floswald]

No I did not.

On Wed, 22 Mar 2017 at 08:47, Michael Krabbe Borregaard <
[email protected]> wrote:

Q1: The actual pyplot GUI (from the REPL).
Q2: Yes, the mac does this resolution reinterpretation automatically. Can
you post how the default size looks on your screen?
Q3: The default – I’d assume that to be the same, but I don’t know how to
check.
I don’t think @floswald changed the size of the window.

—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
https://github.com/JuliaPlots/Plots.jl/issues/739#issuecomment-288322371,
or mute the thread
https://github.com/notifications/unsubscribe-auth/AA-Wdr_bo17DJZ7exOzfIg8Uax7LmNI5ks5roNIigaJpZM4MhaQH
.

[ma-laforge]

Q3: The default – I’d assume that to be the same, but I don’t know how to check.

using PyPlot
pygui() #You will get something like :tk, :wx, :qt, ...

Q2: Yes, the mac does this resolution reinterpretation automatically. Can you post how the default size looks on your screen?

If this question was directed at me, I get the following default dimensions on ubuntu Linux: 600x400.

This seems to match the default specified in args.jl (:size => (600,400))

I noticed @floswald's resolution is 1200x800. Sounds to me like the mac is hearing "I want 600x400" - but is doubling each dimension. I don't think Plots.jl is the one doning this magical scaling.

It appears to me that we should be asking why fonts are not scaled accordingly.

=> I have no useful ideas at the moment. I also have no hardware to experiment with.

[ma-laforge]

Scratch that... I do have 1 idea:

What if PyPlot typically operated at 100dpi, but on retina displays, PyPlot knew to operate at 200dpi?

AFAIK: Plots.jl, is always forcing the default resolution to 100dpi (I don't think it ever listens to the OS).

@mkborregaard: Is it possible you somehow have a default in your .juliarc that forces Plots.jl's :dpi=>200?

If you did, your plot would also show up as 1200x800, but your fonts would still look ok relative to the entire plot (because font sizes would be adjusted).

[mkborregaard]

I have 100 dpi. My PyPlot version is 2.3.1, and pygui is :qt5

[floswald]

ha. @mkborregaard what is your OSX? i am on 10.11.6.
I had an issue with the pygui. https://github.com/JuliaPy/PyPlot.jl/issues/258
i set backend : MacOSX in ~/.matplotlib/matplotlibrc . am i doing something wrong here?

I just set backend : Qt5Agg with the same effect.

I see

julia> PyPlot.version
v"2.0.0"

even after updating PyPlot?

[mkborregaard]

Hm, the current version of PyPlot is v.2.3.1, and the title of the latest release is "qt5 fixes". That should be the first thing to try and fix. Do you have any of the packages under Pkg.dependents("PyPlot") installed? Maybe one of them is causing trouble with requiring a specific PyPlot version. Anecdotally, I had a lot of version problems that were all solved by Pkg.checkout("Images").
btw I am on MacOS 10.12.3

[ma-laforge]

(Angry) mumble... mumble... mumble...

After the upgrade to Matplotlib 2.0, I spent something like 2 months with issues similar to what you described in https://github.com/JuliaPy/PyPlot.jl/issues/258.

Everything worked fine with the older version of matplotlib. I used to get a :tk gui.

After the 2.0 upgrade, I would get a message saying something like "no gui backend selected"... So I used the following hack:

using PyCall
pygui(:tk) #Has to happen BEFORE PyPlot first gets used
using PyPlot

This was very annoying. I just figured out your solution Yesterday @floswald. Would have saved me alot of time if I were aware of this solution before!

...Maybe I should open an issue for the PyPlot documentation...

EDIT: The PyPlot documentation does provide a link to modifying the "matplotibrc" file in "Choosing a Python GUI toolkit".... But your example seems much clearer/simpler/more robust to me, @floswald .

I'll probably have to think of a way to better word this...

[floswald]

phew...

julia> Pkg.dependents("PyPlot")
23-element Array{AbstractString,1}:
 "YT"                           
 "ClimateTools"                 
 "DCEMRI"                       
 "GeneralizedMetropolisHastings"
 "Shearlab"                     
 "Seaborn"                      
 "EasyPhys"                     
 "Pandas"                       
 "Augur"                        
 "PerceptualColourMaps"         
 "DynamicalBilliards"           
 "DriftDiffusionPoissonSystems" 
 "EllipticFEM"                  
 "BiomolecularStructures"       
 "ImageProjectiveGeometry"      
 "Seismic"                      
 "ShapeModels"                  
 "Laplacians"                   
 "Spectra"                      
 "JFVM"                         
 "ConstructiveSolidGeometry"    
 "EMIRT"                        
 "Mads"

how could i find out which package is requiring what version?

[floswald]

what's more worrying is that I dont' knwo a single package from that list...

[mkborregaard]

If you don't have them installed they shouldn't cause problems. Also, try the Images trick (if you have it installed, of course)

[floswald]

I did Pkg.pin("PyPlot",v"2.3.1"), and in Pkg.status() the right version shows up. but

julia> PyPlot.version
v"2.0.0"

this is after restarting and rebuilding PyPlot. anyway, the plot still looks the same.

[ma-laforge]

What if you just read in the dpi setting to be sure:

using PyPlot
f=figure()
@show f[:dpi]

And, in a new Julia session:

using Plots
p=plot()
@show p.attr[:dpi]

[mkborregaard]

Yes, that is your matplotlib version number.

[ma-laforge]

FYI @floswald : The Pkg.pin("PyPlot",v"2.3.1") version is the "Julia PyPlot" wrapper (PyPlot.jl) - whereas PyPlot.version is the actual Python library version

[floswald]

@ma-laforge here you go:

julia> using Plots

julia> p=plot()
sys:1: MatplotlibDeprecationWarning: The set_axis_bgcolor function was deprecated in version 2.0. Use set_facecolor instead.

julia> @show p.attr[:dpi]
p.attr[:dpi] = 100
100

another session:

julia> using PyPlot
INFO: Recompiling stale cache file /Users/florian.oswald/.julia/lib/v0.5/PyCall.ji for module PyCall.
INFO: Recompiling stale cache file /Users/florian.oswald/.julia/lib/v0.5/PyPlot.ji for module PyPlot.

julia> f=figure()
PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x3280aa150>)

julia> @show f[:dpi]
f[:dpi] = 200.0
200.0

[mkborregaard]

@floswald with the deprecation warning it doesn't sound like you are on Plots master?

[mkborregaard]

Ah but clearly that's it. PyPlot knows you're on retina it appears and has set your dpi to 200. It should be possible to get that dpi calculation out of PyPlot.

[floswald]

bingo! good work guys.

by the way, what would you do with that:

julia> Pkg.checkout("Plots")
INFO: Checking out Plots master...
INFO: Pulling Plots latest master...
ERROR: unsatisfiable package requirements detected: no feasible version could be found for package: Compat
  (you may try increasing the value of the
   JULIA_PKGRESOLVE_ACCURACY environment variable)
 in resolve(::Dict{String,Base.Pkg.Types.VersionSet}, ::Dict{String,Dict{VersionNumber,Base.Pkg.Types.Available}}) at ./pkg/resolve.jl:37
 in resolve(::Dict{String,Base.Pkg.Types.VersionSet}, ::Dict{String,Dict{VersionNumber,Base.Pkg.Types.Available}}, ::Dict{String,Tuple{VersionNumber,Bool}}, ::Dict{String,Base.Pkg.Types.Fixed}, ::Dict{String,VersionNumber}, ::Set{String}) at ./pkg/entry.jl:495
 in resolve(::Dict{String,Base.Pkg.Types.VersionSet}, ::Dict{String,Dict{VersionNumber,Base.Pkg.Types.Available}}, ::Dict{String,Tuple{VersionNumber,Bool}}, ::Dict{String,Base.Pkg.Types.Fixed}) at ./pkg/entry.jl:476
 in (::Base.Pkg.Entry.##18#20{String,String,Bool,Bool})(::Base.LibGit2.GitRepo) at ./pkg/entry.jl:237
 in transact(::Base.Pkg.Entry.##18#20{String,String,Bool,Bool}, ::Base.LibGit2.GitRepo) at ./libgit2/libgit2.jl:520
 in with(::Base.Pkg.Entry.##17#19{String,String,Bool,Bool}, ::Base.LibGit2.GitRepo) at ./libgit2/types.jl:638
 in checkout(::String, ::String, ::Bool, ::Bool) at ./pkg/entry.jl:227
 in (::Base.Pkg.Dir.##2#3{Array{Any,1},Base.Pkg.Entry.#checkout,Tuple{String,String,Bool,Bool}})() at ./pkg/dir.jl:31
 in cd(::Base.Pkg.Dir.##2#3{Array{Any,1},Base.Pkg.Entry.#checkout,Tuple{String,String,Bool,Bool}}, ::String) at ./file.jl:59
 in #cd#1(::Array{Any,1}, ::Function, ::Function, ::String, ::Vararg{Any,N}) at ./pkg/dir.jl:31
 in checkout(::String) at ./pkg/pkg.jl:170

[mkborregaard]

Oh no. This doesn't have to be Plots related. It is a recent problem in Pkg. Try setting your JULIA_PKGRESOLVE_ACCURACY environment variable to 4 and retry the operation.

[floswald]

you're the man. worked and deprecation warning is gone. 👍

now let's hope someone picks this up for the next Plots version.