ENH: enable_deconflict property & thread through Locator __init__

tacaswell · tacaswell · commit 98f90434433e · 2019-03-31T23:58:08.000-04:00
diff --git a/lib/matplotlib/dates.py b/lib/matplotlib/dates.py
@@ -1161,10 +1161,11 @@ class DateLocator(ticker.Locator):
     """
     hms0d = {'byhour': 0, 'byminute': 0, 'bysecond': 0}
 
-    def __init__(self, tz=None):
+    def __init__(self, tz=None, **kwargs):
         """
         *tz* is a :class:`tzinfo` instance.
         """
+        super().__init__(**kwargs)
         if tz is None:
             tz = _get_rc_timezone()
         self.tz = tz
@@ -1235,8 +1236,8 @@ def nonsingular(self, vmin, vmax):
 class RRuleLocator(DateLocator):
     # use the dateutil rrule instance
 
-    def __init__(self, o, tz=None):
-        DateLocator.__init__(self, tz)
+    def __init__(self, o, tz=None, **kwargs):
+        super().__init__(tz, **kwargs)
         self.rule = o
 
     def __call__(self):
@@ -1344,7 +1345,7 @@ class AutoDateLocator(DateLocator):
     locations.
     """
     def __init__(self, tz=None, minticks=5, maxticks=None,
-                 interval_multiples=True):
+                 interval_multiples=True, **kwargs):
         """
         *minticks* is the minimum number of ticks desired, which is used to
         select the type of ticking (yearly, monthly, etc.).
@@ -1391,7 +1392,7 @@ def __init__(self, tz=None, minticks=5, maxticks=None,
           locator = AutoDateLocator()
           locator.intervald[HOURLY] = [3] # only show every 3 hours
         """
-        DateLocator.__init__(self, tz)
+        super().__init__(tz, **kwargs)
         self._locator = YearLocator(tz=tz)
         self._freq = YEARLY
         self._freqs = [YEARLY, MONTHLY, DAILY, HOURLY, MINUTELY,
@@ -1586,12 +1587,12 @@ class YearLocator(DateLocator):
       # Tick every 5 years on July 4th
       locator = YearLocator(5, month=7, day=4)
     """
-    def __init__(self, base=1, month=1, day=1, tz=None):
+    def __init__(self, base=1, month=1, day=1, tz=None, **kwargs):
         """
         Mark years that are multiple of base on a given month and day
         (default jan 1).
         """
-        DateLocator.__init__(self, tz)
+        super().__init__(tz, **kwargs)
         self.base = ticker._Edge_integer(base, 0)
         self.replaced = {'month':  month,
                          'day':    day,
@@ -1660,7 +1661,8 @@ class MonthLocator(RRuleLocator):
     """
     Make ticks on occurrences of each month, e.g., 1, 3, 12.
     """
-    def __init__(self, bymonth=None, bymonthday=1, interval=1, tz=None):
+    def __init__(self, bymonth=None, bymonthday=1, interval=1, tz=None,
+                 **kwargs):
         """
         Mark every month in *bymonth*; *bymonth* can be an int or
         sequence.  Default is ``range(1,13)``, i.e. every month.
@@ -1678,15 +1680,15 @@ def __init__(self, bymonth=None, bymonthday=1, interval=1, tz=None):
 
         rule = rrulewrapper(MONTHLY, bymonth=bymonth, bymonthday=bymonthday,
                             interval=interval, **self.hms0d)
-        RRuleLocator.__init__(self, rule, tz)
+        super().__init__(rule, tz, **kwargs)
 
 
 class WeekdayLocator(RRuleLocator):
     """
     Make ticks on occurrences of each weekday.
     """
 
-    def __init__(self, byweekday=1, interval=1, tz=None):
+    def __init__(self, byweekday=1, interval=1, tz=None, **kwargs):
         """
         Mark every weekday in *byweekday*; *byweekday* can be a number or
         sequence.
@@ -1706,15 +1708,15 @@ def __init__(self, byweekday=1, interval=1, tz=None):
 
         rule = rrulewrapper(DAILY, byweekday=byweekday,
                             interval=interval, **self.hms0d)
-        RRuleLocator.__init__(self, rule, tz)
+        super().__init__(rule, tz, **kwargs)
 
 
 class DayLocator(RRuleLocator):
     """
     Make ticks on occurrences of each day of the month.  For example,
     1, 15, 30.
     """
-    def __init__(self, bymonthday=None, interval=1, tz=None):
+    def __init__(self, bymonthday=None, interval=1, tz=None, **kwargs):
         """
         Mark every day in *bymonthday*; *bymonthday* can be an int or
         sequence.
@@ -1733,14 +1735,14 @@ def __init__(self, bymonthday=None, interval=1, tz=None):
 
         rule = rrulewrapper(DAILY, bymonthday=bymonthday,
                             interval=interval, **self.hms0d)
-        RRuleLocator.__init__(self, rule, tz)
+        super().__init__(rule, tz, **kwargs)
 
 
 class HourLocator(RRuleLocator):
     """
     Make ticks on occurrences of each hour.
     """
-    def __init__(self, byhour=None, interval=1, tz=None):
+    def __init__(self, byhour=None, interval=1, tz=None, **kwargs):
         """
         Mark every hour in *byhour*; *byhour* can be an int or sequence.
         Default is to tick every hour: ``byhour=range(24)``
@@ -1753,14 +1755,14 @@ def __init__(self, byhour=None, interval=1, tz=None):
 
         rule = rrulewrapper(HOURLY, byhour=byhour, interval=interval,
                             byminute=0, bysecond=0)
-        RRuleLocator.__init__(self, rule, tz)
+        super().__init__(rule, tz, **kwargs)
 
 
 class MinuteLocator(RRuleLocator):
     """
     Make ticks on occurrences of each minute.
     """
-    def __init__(self, byminute=None, interval=1, tz=None):
+    def __init__(self, byminute=None, interval=1, tz=None, **kwargs):
         """
         Mark every minute in *byminute*; *byminute* can be an int or
         sequence.  Default is to tick every minute: ``byminute=range(60)``
@@ -1773,14 +1775,14 @@ def __init__(self, byminute=None, interval=1, tz=None):
 
         rule = rrulewrapper(MINUTELY, byminute=byminute, interval=interval,
                             bysecond=0)
-        RRuleLocator.__init__(self, rule, tz)
+        super().__init__(rule, tz, **kwargs)
 
 
 class SecondLocator(RRuleLocator):
     """
     Make ticks on occurrences of each second.
     """
-    def __init__(self, bysecond=None, interval=1, tz=None):
+    def __init__(self, bysecond=None, interval=1, tz=None, **kwargs):
         """
         Mark every second in *bysecond*; *bysecond* can be an int or
         sequence.  Default is to tick every second: ``bysecond = range(60)``
@@ -1793,7 +1795,7 @@ def __init__(self, bysecond=None, interval=1, tz=None):
             bysecond = range(60)
 
         rule = rrulewrapper(SECONDLY, bysecond=bysecond, interval=interval)
-        RRuleLocator.__init__(self, rule, tz)
+        super().__init__(self, rule, tz, **kwargs)
 
 
 class MicrosecondLocator(DateLocator):
@@ -1815,12 +1817,13 @@ class MicrosecondLocator(DateLocator):
         early years; using year 0001 is recommended.
 
     """
-    def __init__(self, interval=1, tz=None):
+    def __init__(self, interval=1, tz=None, **kwargs):
         """
         *interval* is the interval between each iteration.  For
         example, if ``interval=2``, mark every second microsecond.
 
         """
+        super().__init__(**kwargs)
         self._interval = interval
         self._wrapped_locator = ticker.MultipleLocator(interval)
         self.tz = tz
diff --git a/lib/matplotlib/ticker.py b/lib/matplotlib/ticker.py
@@ -1469,6 +1469,19 @@ class Locator(TickHelper):
     # many ticks are generated.
     MAXTICKS = 1000
 
+    def __init__(self, *args, enable_deconflict=True, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._enable_deconflict = enable_deconflict
+
+    def get_enable_deconfilct(self):
+        return self._enable_deconflict
+
+    def set_enable_deconflict(self, value):
+        self._enable_deconflict = bool(value)
+
+    enable_deconflict = property(get_enable_deconfilct,
+                                 set_enable_deconflict)
+
     def tick_values(self, vmin, vmax):
         """
         Return the values of the located ticks given **vmin** and **vmax**.
@@ -1564,8 +1577,9 @@ class IndexLocator(Locator):
     index plotting; i.e., the axis is 0, len(data).  This is mainly
     useful for x ticks.
     """
-    def __init__(self, base, offset):
+    def __init__(self, base, offset, **kwargs):
         'place ticks on the i-th data points where (i-offset)%base==0'
+        super().__init__(**kwargs)
         self._base = base
         self.offset = offset
 
@@ -1597,7 +1611,8 @@ class FixedLocator(Locator):
     the chosen ticks.
     """
 
-    def __init__(self, locs, nbins=None):
+    def __init__(self, locs, nbins=None, **kwargs):
+        super().__init__(**kwargs)
         self.locs = np.asarray(locs)
         self.nbins = max(nbins, 2) if nbins is not None else None
 
@@ -1660,10 +1675,11 @@ class LinearLocator(Locator):
     be nice
 
     """
-    def __init__(self, numticks=None, presets=None):
+    def __init__(self, numticks=None, presets=None, **kwargs):
         """
         Use presets to set locs based on lom.  A dict mapping vmin, vmax->locs
         """
+        super().__init__(**kwargs)
         self.numticks = numticks
         if presets is None:
             self.presets = {}
@@ -1775,7 +1791,8 @@ class MultipleLocator(Locator):
     Set a tick on each integer multiple of a base within the view interval.
     """
 
-    def __init__(self, base=1.0):
+    def __init__(self, base=1.0, **kwargs):
+        super().__init__(**kwargs)
         self._edge = _Edge_integer(base, 0)
 
     def set_params(self, base):
@@ -1919,6 +1936,8 @@ def __init__(self, *args, **kwargs):
             this minimum number of ticks.
 
         """
+        enable_deconflict = kwargs.pop('enable_deconflict', True)
+        super().__init__(enable_deconflict=enable_deconflict)
         if args:
             if 'nbins' in kwargs:
                 cbook.deprecated("3.1",
@@ -2202,7 +2221,8 @@ class LogLocator(Locator):
     Determine the tick locations for log axes
     """
 
-    def __init__(self, base=10.0, subs=(1.0,), numdecs=4, numticks=None):
+    def __init__(self, base=10.0, subs=(1.0,), numdecs=4, numticks=None,
+                 **kwargs):
         """
         Place ticks on the locations : subs[j] * base**i
 
@@ -2221,6 +2241,7 @@ def __init__(self, base=10.0, subs=(1.0,), numdecs=4, numticks=None):
             equivalent to ``'auto'``.
 
         """
+        super().__init__(**kwargs)
         if numticks is None:
             if rcParams['_internal.classic_mode']:
                 numticks = 15
@@ -2403,10 +2424,12 @@ class SymmetricalLogLocator(Locator):
     Determine the tick locations for symmetric log axes
     """
 
-    def __init__(self, transform=None, subs=None, linthresh=None, base=None):
+    def __init__(self, transform=None, subs=None, linthresh=None,
+                 base=None, **kwargs):
         """
         place ticks on the location= base**i*subs[j]
         """
+        super().__init__(**kwargs)
         if transform is not None:
             self._base = transform.base
             self._linthresh = transform.linthresh
@@ -2563,10 +2586,11 @@ class LogitLocator(Locator):
     Determine the tick locations for logit axes
     """
 
-    def __init__(self, minor=False):
+    def __init__(self, minor=False, **kwargs):
         """
         place ticks on the logit locations
         """
+        super().__init__(**kwargs)
         self.minor = minor
 
     def set_params(self, minor=None):
@@ -2656,11 +2680,12 @@ class AutoLocator(MaxNLocator):
     of `~matplotlib.ticker.MaxNLocator`, with parameters *nbins = 'auto'*
     and *steps = [1, 2, 2.5, 5, 10]*.
     """
-    def __init__(self):
+    def __init__(self, **kwargs):
         """
         To know the values of the non-public parameters, please have a
         look to the defaults of `~matplotlib.ticker.MaxNLocator`.
         """
+        super().__init__(**kwargs)
         if rcParams['_internal.classic_mode']:
             nbins = 9
             steps = [1, 2, 5, 10]
@@ -2675,14 +2700,15 @@ class AutoMinorLocator(Locator):
     Dynamically find minor tick positions based on the positions of
     major ticks. The scale must be linear with major ticks evenly spaced.
     """
-    def __init__(self, n=None):
+    def __init__(self, n=None, **kwargs):
         """
         *n* is the number of subdivisions of the interval between
         major ticks; e.g., n=2 will place a single minor tick midway
         between major ticks.
 
         If *n* is omitted or None, it will be set to 5 or 4.
         """
+        super().__init__(**kwargs)
         self.ndivs = n
 
     def __call__(self):
@@ -2737,7 +2763,8 @@ class OldAutoLocator(Locator):
     view limits and the tick locs.
 
     """
-    def __init__(self):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
         self._locator = LinearLocator()
 
     def __call__(self):
