Skip to content

Dedupe various method implementations using functools.partialmethod. #19654

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Mar 10, 2021
Merged

Dedupe various method implementations using functools.partialmethod. #19654

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
34 changes: 14 additions & 20 deletions lib/matplotlib/backends/backend_cairo.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@
This backend depends on cairocffi or pycairo.
"""

import functools
import gzip
import math

Expand Down Expand Up @@ -467,20 +468,8 @@ def _get_printed_image_surface(self):
self.figure.draw(renderer)
return surface

def print_pdf(self, fobj, *args, **kwargs):
return self._save(fobj, 'pdf', *args, **kwargs)

def print_ps(self, fobj, *args, **kwargs):
return self._save(fobj, 'ps', *args, **kwargs)

def print_svg(self, fobj, *args, **kwargs):
return self._save(fobj, 'svg', *args, **kwargs)

def print_svgz(self, fobj, *args, **kwargs):
return self._save(fobj, 'svgz', *args, **kwargs)

@_check_savefig_extra_args
def _save(self, fo, fmt, *, orientation='portrait'):
def _save(self, fmt, fobj, *, orientation='portrait'):
# save PDF/PS/SVG

dpi = 72
Expand All @@ -496,22 +485,22 @@ def _save(self, fo, fmt, *, orientation='portrait'):
if not hasattr(cairo, 'PSSurface'):
raise RuntimeError('cairo has not been compiled with PS '
'support enabled')
surface = cairo.PSSurface(fo, width_in_points, height_in_points)
surface = cairo.PSSurface(fobj, width_in_points, height_in_points)
elif fmt == 'pdf':
if not hasattr(cairo, 'PDFSurface'):
raise RuntimeError('cairo has not been compiled with PDF '
'support enabled')
surface = cairo.PDFSurface(fo, width_in_points, height_in_points)
surface = cairo.PDFSurface(fobj, width_in_points, height_in_points)
elif fmt in ('svg', 'svgz'):
if not hasattr(cairo, 'SVGSurface'):
raise RuntimeError('cairo has not been compiled with SVG '
'support enabled')
if fmt == 'svgz':
if isinstance(fo, str):
fo = gzip.GzipFile(fo, 'wb')
if isinstance(fobj, str):
fobj = gzip.GzipFile(fobj, 'wb')
else:
fo = gzip.GzipFile(None, 'wb', fileobj=fo)
surface = cairo.SVGSurface(fo, width_in_points, height_in_points)
fobj = gzip.GzipFile(None, 'wb', fileobj=fobj)
surface = cairo.SVGSurface(fobj, width_in_points, height_in_points)
else:
raise ValueError("Unknown format: {!r}".format(fmt))

Expand All @@ -531,7 +520,12 @@ def _save(self, fo, fmt, *, orientation='portrait'):
ctx.show_page()
surface.finish()
if fmt == 'svgz':
fo.close()
fobj.close()

print_pdf = functools.partialmethod(_save, "pdf")
print_ps = functools.partialmethod(_save, "ps")
print_svg = functools.partialmethod(_save, "svg")
print_svgz = functools.partialmethod(_save, "svgz")


@_Backend.export
Expand Down
37 changes: 15 additions & 22 deletions lib/matplotlib/backends/backend_wx.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,7 @@
Copyright (C) Jeremy O'Donoghue & John Hunter, 2003-4.
"""

import functools
import logging
import math
import pathlib
Expand Down Expand Up @@ -829,29 +830,8 @@ def draw(self, drawDC=None):
self._isDrawn = True
self.gui_repaint(drawDC=drawDC)

def print_bmp(self, filename, *args, **kwargs):
return self._print_image(filename, wx.BITMAP_TYPE_BMP, *args, **kwargs)

def print_jpeg(self, filename, *args, **kwargs):
return self._print_image(filename, wx.BITMAP_TYPE_JPEG,
*args, **kwargs)
print_jpg = print_jpeg

def print_pcx(self, filename, *args, **kwargs):
return self._print_image(filename, wx.BITMAP_TYPE_PCX, *args, **kwargs)

def print_png(self, filename, *args, **kwargs):
return self._print_image(filename, wx.BITMAP_TYPE_PNG, *args, **kwargs)

def print_tiff(self, filename, *args, **kwargs):
return self._print_image(filename, wx.BITMAP_TYPE_TIF, *args, **kwargs)
print_tif = print_tiff

def print_xpm(self, filename, *args, **kwargs):
return self._print_image(filename, wx.BITMAP_TYPE_XPM, *args, **kwargs)

@_check_savefig_extra_args
def _print_image(self, filename, filetype, *, quality=None):
def _print_image(self, filetype, filename, *, quality=None):
origBitmap = self.bitmap

self.bitmap = wx.Bitmap(math.ceil(self.figure.bbox.width),
Expand Down Expand Up @@ -897,6 +877,19 @@ def _print_image(self, filename, filetype, *, quality=None):
if self:
self.Refresh()

print_bmp = functools.partialmethod(
_print_image, wx.BITMAP_TYPE_BMP)
print_jpeg = print_jpg = functools.partialmethod(
_print_image, wx.BITMAP_TYPE_JPEG)
print_pcx = functools.partialmethod(
_print_image, wx.BITMAP_TYPE_PCX)
print_png = functools.partialmethod(
_print_image, wx.BITMAP_TYPE_PNG)
print_tiff = print_tif = functools.partialmethod(
_print_image, wx.BITMAP_TYPE_TIF)
print_xpm = functools.partialmethod(
_print_image, wx.BITMAP_TYPE_XPM)


class FigureFrameWx(wx.Frame):
def __init__(self, num, fig):
Expand Down
49 changes: 11 additions & 38 deletions lib/matplotlib/testing/jpl_units/Duration.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
"""Duration module."""

import functools
import operator

from matplotlib import _api
Expand Down Expand Up @@ -44,38 +45,20 @@ def seconds(self):
def __bool__(self):
return self._seconds != 0

def __eq__(self, rhs):
return self._cmp(rhs, operator.eq)

def __ne__(self, rhs):
return self._cmp(rhs, operator.ne)

def __lt__(self, rhs):
return self._cmp(rhs, operator.lt)

def __le__(self, rhs):
return self._cmp(rhs, operator.le)

def __gt__(self, rhs):
return self._cmp(rhs, operator.gt)

def __ge__(self, rhs):
return self._cmp(rhs, operator.ge)

def _cmp(self, rhs, op):
def _cmp(self, op, rhs):
"""
Compare two Durations.

= INPUT VARIABLES
- rhs The Duration to compare against.
- op The function to do the comparison

= RETURN VALUE
- Returns op(self, rhs)
Check that *self* and *rhs* share frames; compare them using *op*.
"""
self.checkSameFrame(rhs, "compare")
return op(self._seconds, rhs._seconds)

__eq__ = functools.partialmethod(_cmp, operator.eq)
__ne__ = functools.partialmethod(_cmp, operator.ne)
__lt__ = functools.partialmethod(_cmp, operator.lt)
__le__ = functools.partialmethod(_cmp, operator.le)
__gt__ = functools.partialmethod(_cmp, operator.gt)
__ge__ = functools.partialmethod(_cmp, operator.ge)

def __add__(self, rhs):
"""
Add two Durations.
Expand Down Expand Up @@ -126,17 +109,7 @@ def __mul__(self, rhs):
"""
return Duration(self._frame, self._seconds * float(rhs))

def __rmul__(self, lhs):
"""
Scale a Duration by a value.

= INPUT VARIABLES
- lhs The scalar to multiply by.

= RETURN VALUE
- Returns the scaled Duration.
"""
return Duration(self._frame, self._seconds * float(lhs))
__rmul__ = __mul__

def __str__(self):
"""Print the Duration."""
Expand Down
41 changes: 10 additions & 31 deletions lib/matplotlib/testing/jpl_units/Epoch.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
"""Epoch module."""

import functools
import operator
import math
import datetime as DT
Expand Down Expand Up @@ -106,44 +107,22 @@ def secondsPast(self, frame, jd):
delta = t._jd - jd
return t._seconds + delta * 86400

def __eq__(self, rhs):
return self._cmp(rhs, operator.eq)

def __ne__(self, rhs):
return self._cmp(rhs, operator.ne)

def __lt__(self, rhs):
return self._cmp(rhs, operator.lt)

def __le__(self, rhs):
return self._cmp(rhs, operator.le)

def __gt__(self, rhs):
return self._cmp(rhs, operator.gt)

def __ge__(self, rhs):
return self._cmp(rhs, operator.ge)

def _cmp(self, rhs, op):
"""
Compare two Epoch's.

= INPUT VARIABLES
- rhs The Epoch to compare against.
- op The function to do the comparison

= RETURN VALUE
- Returns op(self, rhs)
"""
def _cmp(self, op, rhs):
"""Compare Epochs *self* and *rhs* using operator *op*."""
t = self
if self._frame != rhs._frame:
t = self.convert(rhs._frame)

if t._jd != rhs._jd:
return op(t._jd, rhs._jd)

return op(t._seconds, rhs._seconds)

__eq__ = functools.partialmethod(_cmp, operator.eq)
__ne__ = functools.partialmethod(_cmp, operator.ne)
__lt__ = functools.partialmethod(_cmp, operator.lt)
__le__ = functools.partialmethod(_cmp, operator.le)
__gt__ = functools.partialmethod(_cmp, operator.gt)
__ge__ = functools.partialmethod(_cmp, operator.ge)

def __add__(self, rhs):
"""
Add a duration to an Epoch.
Expand Down
106 changes: 20 additions & 86 deletions lib/matplotlib/testing/jpl_units/UnitDbl.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
"""UnitDbl module."""

import functools
import operator

from matplotlib import _api
Expand Down Expand Up @@ -88,99 +89,32 @@ def __bool__(self):
"""Return the truth value of a UnitDbl."""
return bool(self._value)

def __eq__(self, rhs):
return self._cmp(rhs, operator.eq)

def __ne__(self, rhs):
return self._cmp(rhs, operator.ne)

def __lt__(self, rhs):
return self._cmp(rhs, operator.lt)

def __le__(self, rhs):
return self._cmp(rhs, operator.le)

def __gt__(self, rhs):
return self._cmp(rhs, operator.gt)

def __ge__(self, rhs):
return self._cmp(rhs, operator.ge)

def _cmp(self, rhs, op):
"""
Compare two UnitDbl's.

= ERROR CONDITIONS
- If the input rhs units are not the same as our units,
an error is thrown.

= INPUT VARIABLES
- rhs The UnitDbl to compare against.
- op The function to do the comparison

= RETURN VALUE
- Returns op(self, rhs)
"""
def _cmp(self, op, rhs):
"""Check that *self* and *rhs* share units; compare them using *op*."""
self.checkSameUnits(rhs, "compare")
return op(self._value, rhs._value)

def __add__(self, rhs):
"""
Add two UnitDbl's.

= ERROR CONDITIONS
- If the input rhs units are not the same as our units,
an error is thrown.

= INPUT VARIABLES
- rhs The UnitDbl to add.

= RETURN VALUE
- Returns the sum of ourselves and the input UnitDbl.
"""
self.checkSameUnits(rhs, "add")
return UnitDbl(self._value + rhs._value, self._units)

def __sub__(self, rhs):
"""
Subtract two UnitDbl's.

= ERROR CONDITIONS
- If the input rhs units are not the same as our units,
an error is thrown.

= INPUT VARIABLES
- rhs The UnitDbl to subtract.

= RETURN VALUE
- Returns the difference of ourselves and the input UnitDbl.
"""
self.checkSameUnits(rhs, "subtract")
return UnitDbl(self._value - rhs._value, self._units)
__eq__ = functools.partialmethod(_cmp, operator.eq)
__ne__ = functools.partialmethod(_cmp, operator.ne)
__lt__ = functools.partialmethod(_cmp, operator.lt)
__le__ = functools.partialmethod(_cmp, operator.le)
__gt__ = functools.partialmethod(_cmp, operator.gt)
__ge__ = functools.partialmethod(_cmp, operator.ge)

def __mul__(self, rhs):
"""
Scale a UnitDbl by a value.
def _binop_unit_unit(self, op, rhs):
"""Check that *self* and *rhs* share units; combine them using *op*."""
self.checkSameUnits(rhs, op.__name__)
return UnitDbl(op(self._value, rhs._value), self._units)

= INPUT VARIABLES
- rhs The scalar to multiply by.
__add__ = functools.partialmethod(_binop_unit_unit, operator.add)
__sub__ = functools.partialmethod(_binop_unit_unit, operator.sub)

= RETURN VALUE
- Returns the scaled UnitDbl.
"""
return UnitDbl(self._value * rhs, self._units)
def _binop_unit_scalar(self, op, scalar):
"""Combine *self* and *scalar* using *op*."""
return UnitDbl(op(self._value, scalar), self._units)

def __rmul__(self, lhs):
"""
Scale a UnitDbl by a value.

= INPUT VARIABLES
- lhs The scalar to multiply by.

= RETURN VALUE
- Returns the scaled UnitDbl.
"""
return UnitDbl(self._value * lhs, self._units)
__mul__ = functools.partialmethod(_binop_unit_scalar, operator.mul)
__rmul__ = functools.partialmethod(_binop_unit_scalar, operator.mul)

def __str__(self):
"""Print the UnitDbl."""
Expand Down