[PATCH 3/8] Disable abstract method warnings in intermediate abstract classes.

David Shea dshea at redhat.com
Wed Dec 11 19:04:09 UTC 2013


pylint can't tell if an intermediate class inheriting from an abstract
class is itself abstract, so just disable the warning where appropriate.

Also, for the classes that were missing it, add checks in __init__ that
an intermediate abstract class is not being instantiated.
---
 pyanaconda/bootloader.py             |  2 ++
 pyanaconda/packaging/__init__.py     | 26 ++++++++++++++++++++++++--
 pyanaconda/packaging/tarpayload.py   |  2 ++
 pyanaconda/ui/common.py              |  4 ++++
 pyanaconda/ui/gui/spokes/__init__.py |  7 +++++++
 pyanaconda/ui/tui/spokes/__init__.py | 15 +++++++++++++++
 6 files changed, 54 insertions(+), 2 deletions(-)

diff --git a/pyanaconda/bootloader.py b/pyanaconda/bootloader.py
index b397f96..737cb6b 100644
--- a/pyanaconda/bootloader.py
+++ b/pyanaconda/bootloader.py
@@ -1747,6 +1747,8 @@ class MacEFIGRUB(EFIGRUB):
         return valid
 
 
+# Inherit abstract methods from BootLoader
+# pylint: disable-msg=W0223
 class YabootBase(BootLoader):
     def write_config_password(self, config):
         if self.password:
diff --git a/pyanaconda/packaging/__init__.py b/pyanaconda/packaging/__init__.py
index da26c67..c10ecd2 100644
--- a/pyanaconda/packaging/__init__.py
+++ b/pyanaconda/packaging/__init__.py
@@ -107,6 +107,9 @@ class Payload(object):
     def __init__(self, data):
         """ data is a kickstart.AnacondaKSHandler class
         """
+        if self.__class__ is Payload:
+            raise TypeError("Payload is an abstract class")
+
         self.data = data
         self.storage = None
         self._kernelVersionList = []
@@ -657,18 +660,37 @@ class Payload(object):
 
         self._copyDriverDiskFiles()
 
+# Inherit abstract methods from Payload
+# pylint: disable-msg=W0223
 class ImagePayload(Payload):
     """ An ImagePayload installs an OS image to the target system. """
-    pass
 
+    def __init__(self, data):
+        if self.__class__ is ImagePayload:
+            raise TypeError("ImagePayload is an abstract class")
+
+        Payload.__init__(self, data)
+
+# Inherit abstract methods from ImagePayload
+# pylint: disable-msg=W0223
 class ArchivePayload(ImagePayload):
     """ An ArchivePayload unpacks source archives onto the target system. """
-    pass
 
+    def __init__(self, data):
+        if self.__class__ is ArchivePayload:
+            raise TypeError("ArchivePayload is an abstract class")
+
+        ImagePayload.__init__(self, data)
+
+# Inherit abstract methods from ImagePayload
+# pylint: disable-msg=W0223
 class PackagePayload(Payload):
     """ A PackagePayload installs a set of packages onto the target system. """
 
     def __init__(self, data):
+        if self.__class__ is PackagePayload:
+            raise TypeError("PackagePayload is an abstract class")
+
         super(PackagePayload, self).__init__(data)
         self.install_device = None
 
diff --git a/pyanaconda/packaging/tarpayload.py b/pyanaconda/packaging/tarpayload.py
index 33bc07e..ce601d5 100644
--- a/pyanaconda/packaging/tarpayload.py
+++ b/pyanaconda/packaging/tarpayload.py
@@ -39,6 +39,8 @@ except ImportError:
 from pyanaconda.constants import ROOT_PATH
 from pyanaconda.packaging import ArchivePayload, PayloadError
 
+# TarPayload is not yet fully implemented
+# pylint: disable-msg=W0223
 class TarPayload(ArchivePayload):
     """ A TarPayload unpacks a single tar archive onto the target system. """
     def __init__(self, data):
diff --git a/pyanaconda/ui/common.py b/pyanaconda/ui/common.py
index 49a93e6..cc48e4a 100644
--- a/pyanaconda/ui/common.py
+++ b/pyanaconda/ui/common.py
@@ -333,6 +333,8 @@ class Spoke(UIObject):
         """
         log.debug("Left spoke: %s", self.__class__.__name__)
 
+# Inherit abstract methods from Spoke
+# pylint: disable-msg=W0223
 class NormalSpoke(Spoke):
     """A NormalSpoke is a Spoke subclass that is displayed when the user
        selects something on a Hub.  This is what most Spokes in anaconda will
@@ -382,6 +384,8 @@ class NormalSpoke(Spoke):
         """
         return True
 
+# Inherit abstract methods from NormalSpoke
+# pylint: disable-msg=W0223
 class StandaloneSpoke(NormalSpoke):
     """A StandaloneSpoke is a Spoke subclass that is displayed apart from any
        Hub.  It is suitable to be used as a Welcome screen.
diff --git a/pyanaconda/ui/gui/spokes/__init__.py b/pyanaconda/ui/gui/spokes/__init__.py
index dd5adf9..20a80ac 100644
--- a/pyanaconda/ui/gui/spokes/__init__.py
+++ b/pyanaconda/ui/gui/spokes/__init__.py
@@ -57,6 +57,8 @@ class Spoke(GUIObject):
         """
         pass
 
+# Inherit abstract methods from Spoke and common.StandaloneSpoke
+# pylint: disable-msg=W0223
 class StandaloneSpoke(Spoke, common.StandaloneSpoke):
     def __init__(self, data, storage, payload, instclass):
         Spoke.__init__(self, data)
@@ -72,8 +74,13 @@ class StandaloneSpoke(Spoke, common.StandaloneSpoke):
         elif event == "quit":
             self.window.connect("quit-clicked", lambda *args: cb())
 
+# Inherit abstract methods from common.NormalSpoke
+# pylint: disable-msg=W0223
 class NormalSpoke(Spoke, common.NormalSpoke):
     def __init__(self, data, storage, payload, instclass):
+        if self.__class__ is NormalSpoke:
+            raise TypeError("NormalSpoke is an abstract class")
+
         Spoke.__init__(self, data)
         common.NormalSpoke.__init__(self, data, storage, payload, instclass)
 
diff --git a/pyanaconda/ui/tui/spokes/__init__.py b/pyanaconda/ui/tui/spokes/__init__.py
index 7975d6e..89d4d89 100644
--- a/pyanaconda/ui/tui/spokes/__init__.py
+++ b/pyanaconda/ui/tui/spokes/__init__.py
@@ -31,6 +31,8 @@ from pyanaconda.constants import PASSWORD_CONFIRM_ERROR_TUI
 __all__ = ["TUISpoke", "EditTUISpoke", "EditTUIDialog", "EditTUISpokeEntry",
            "NormalTUISpoke", "collect_spokes", "collect_categories"]
 
+# Inherit abstract methods from Spoke
+# pylint: disable-msg=W0223
 class TUISpoke(TUIObject, tui.Widget, Spoke):
     """Base TUI Spoke class implementing the pyanaconda.ui.common.Spoke API.
     It also acts as a Widget so we can easily add it to Hub, where is shows
@@ -47,6 +49,9 @@ class TUISpoke(TUIObject, tui.Widget, Spoke):
     category = u""
 
     def __init__(self, app, data, storage, payload, instclass):
+        if self.__class__ is TUISpoke:
+            raise TypeError("TUISpoke is an abstract class")
+
         TUIObject.__init__(self, app, data)
         tui.Widget.__init__(self)
         Spoke.__init__(self, data, storage, payload, instclass)
@@ -88,6 +93,8 @@ class NormalTUISpoke(TUISpoke, NormalSpoke):
 
 EditTUISpokeEntry = namedtuple("EditTUISpokeEntry", ["title", "attribute", "aux", "visible"])
 
+# Inherit abstract methods from NormalTUISpoke
+# pylint: disable-msg=W0223
 class EditTUIDialog(NormalTUISpoke):
     """Spoke/dialog used to read new value of textual or password data"""
 
@@ -95,6 +102,9 @@ class EditTUIDialog(NormalTUISpoke):
     PASSWORD = re.compile(".*")
 
     def __init__(self, app, data, storage, payload, instclass):
+        if self.__class__ is EditTUIDialog:
+            raise TypeError("EditTUIDialog is an abstract class")
+
         NormalTUISpoke.__init__(self, app, data, storage, payload, instclass)
         self.value = None
 
@@ -165,6 +175,8 @@ class OneShotEditTUIDialog(EditTUIDialog):
 
         return ret
 
+# Inherit abstract methods from NormalTUISpoke
+# pylint: disable-msg=W0223
 class EditTUISpoke(NormalTUISpoke):
     """Spoke with declarative semantics, it contains
        a list of titles, attribute names and regexps
@@ -199,6 +211,9 @@ class EditTUISpoke(NormalTUISpoke):
     ]
 
     def __init__(self, app, data, storage, payload, instclass):
+        if self.__class__ is EditTUISpoke:
+            raise TypeError("EditTUISpoke is an abstract class")
+
         NormalTUISpoke.__init__(self, app, data, storage, payload, instclass)
         self.dialog = OneShotEditTUIDialog(app, data, storage, payload, instclass)
 
-- 
1.8.4.2



More information about the anaconda-patches mailing list