Thanks for the contribution@leakyH! I confirm I can reproduce the behaviour you report withmain:

importmatplotlib.pyplotaspltimportnumpyasnp# Sample datax=np.linspace(10,20,100)y=np.sin(x)fig,ax=plt.subplots()ax.plot(x,y)ax.spines['bottom'].set_bounds(10,None)plt.show()

It looks like you are still working on your fix, so I'm going to mark this as "draft" for now. Please mark it as "ready for review" when you are ready.

Thank you@rcomer !

I just found that one of the tests failed, because I modified the self._bounds in the get_bounds() function in my original fix. Now I've solve it and I will mark it as "ready for review" when all tests pass!

Edited because actually this behaviour is consistent withAxes.set_xlim, as demonstrated in the next comment.

Thanks for your work on this@leakyH.Currently it is not quite right because it fixes the bound you didn't set and prevents further automatic updates to it. Adapting your example:

importmatplotlib.pyplotaspltimportnumpyasnp# Sample datax=np.linspace(10,20,100)y=np.sin(x)fig,ax=plt.subplots()ax.plot(x,y)ax.spines['bottom'].set_bounds(10,None)ax.plot(x*2,y)plt.show()

with your branch, this now gives

But the x-spine should go from 10 to the x-axis upper limit.

I also note thatSpine.get_bounds is public API andwe are quite strict about making changes to the behaviour of that. It can be done, but as you see from the guidelines there are various aspects to weigh up.

I wonder if the issue might be fixed more simply by only changing the waylow andhigh are defined in_adjust_location. Currently it uses the viewlim if neither bound was set. If one element ofself._bounds isNone, could we just replace that element with the relevant element of the viewlim?

yes@rcomer , thank you for your inspiring review, and I know what you mean now.

1. In your demo, the viewLim changes after manuallyset_bounds(), so the spine does not align with the viewLim. You expect that whenset_bounds(10, None), theNone should refer to an automatic/default behaviour, which is to extend to axis's upper/lower limit, a.k.a. viewLim. I need to remind you that this is slightly different from the documentation, which says

Passing None leaves the limit unchanged.

Certainly, we can change the documentation after all. I just want to make sure you notice that and this is what we want. Since thisset_bounds() API did not work in the past, maybe this behaviour change is acceptable.

As a reference, please run this code:

import matplotlib.pyplot as pltimport numpy as np# Sample datax = np.linspace(10, 20, 100)y = np.sin(x)fig, ax = plt.subplots()ax.plot(x, y)# ax.spines['bottom'].set_bounds(10, None)ax.set_xlim(10, None)# Note thisax.plot(x*2, y)plt.savefig('modify_after_set.jpg')

You'll see theNone for xlim also means to keep the original xlim, and does not change for laterax.plot.

2. As you said, I will think of a simpler modification and try to keepget_bounds() returning the internal objectself._bounds.

I think the easiest way is to modify the_adjust_location, and allow the spine to automatically extend to axis's upper/lower limit. But it would be better to clarify what we want before further modifications to the code.

Thank you!

Thank you for thinking this through! You are right and I actually had not realised thatset_xlim works like that. I agree we should makeSpine.set_bounds be consistent withset_xlim, so the behaviour you currently have is correct.

Hi@rcomer , I've updated the code:

1. get_bounds() now returns the internal objectself._bounds as it did.
2. Inset_bounds(), it gets the original bounds as_adjust_location did, so the logic is extracted as a function called_get_bounds_or_viewLim.

And to whom may concern, this PR initailly processed theself._bounds is None situation in theget_bounds() public API, which may bring extra complexity. Based on the feedback, now theset_bounds and_adjust_location both use the internal function_get_bounds_or_viewLim.