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

import matplotlib.pyplot as plt
import numpy as np

# Sample data
x = 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 with Axes.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:

import matplotlib.pyplot as plt
import numpy as np

# Sample data
x = 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 that Spine.get_bounds is public API and we 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 way low and high are defined in _adjust_location. Currently it uses the viewlim if neither bound was set. If one element of self._bounds is None, 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 manually set_bounds(), so the spine does not align with the viewLim. You expect that when set_bounds(10, None), the None 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 this set_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 plt
import numpy as np

# Sample data
x = 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 this
ax.plot(x*2, y)
plt.savefig('modify_after_set.jpg')

You'll see the None for xlim also means to keep the original xlim, and does not change for later ax.plot.

2. As you said, I will think of a simpler modification and try to keep get_bounds() returning the internal object self._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 that set_xlim works like that. I agree we should make Spine.set_bounds be consistent with set_xlim, so the behaviour you currently have is correct.

Hi @rcomer , I've updated the code:

1. get_bounds() now returns the internal object self._bounds as it did.
2. In set_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 the self._bounds is None situation in the get_bounds() public API, which may bring extra complexity. Based on the feedback, now the set_bounds and _adjust_location both use the internal function _get_bounds_or_viewLim.