Merge pull request #80 from jkonecny12/master-remove-pocketlint

Replace pocketlint with pylint

Author: jkonecny12

.pylintrc

@@ -61,8 +61,8 @@ coverage:
 
 .PHONY: check
 check:
-	@echo "*** Running pocketlint ***"
-	PYTHONPATH=. tests/pylint/runpylint.py
+	@echo "*** Running pylint ***"
+	$(PYTHON) -m pylint simpleline/ examples/*/*.py tests/
 
 .PHONY: install
 install:

Makefile

@@ -52,11 +52,17 @@ def refresh(self, args=None):
 
         # Checkbox widget
         # Checkbox which can hold 2 states.
-        checkbox_widget = CheckboxWidget(key="o", title="Checkbox title", text="Checkbox text", completed=True)
+        checkbox_widget = CheckboxWidget(key="o",
+                                         title="Checkbox title",
+                                         text="Checkbox text",
+                                         completed=True)
         self.window.add_with_separator(checkbox_widget)
 
         # Checkbox widget unchecked
-        checkbox_widget_unchecked = CheckboxWidget(key="o", title="Checkbox title", text="Unchecked", completed=False)
+        checkbox_widget_unchecked = CheckboxWidget(key="o",
+                                                   title="Checkbox title",
+                                                   text="Unchecked",
+                                                   completed=False)
         self.window.add_with_separator(checkbox_widget_unchecked)
 
 

examples/01_base_widgets/01_base_widgets.py

@@ -43,11 +43,11 @@ def input(self, args, key):
             ScreenHandler.push_screen(self._counter_spoke)
             # this input was processed
             return InputState.PROCESSED
-        else:
-            # return for outer processing
-            # the basic processing is 'c' for continue, 'r' for refresh, 'q' to quit
-            # otherwise the input is discarded and waiting for a new input
-            return key
+
+        # return for outer processing
+        # the basic processing is 'c' for continue, 'r' for refresh, 'q' to quit
+        # otherwise the input is discarded and waiting for a new input
+        return key
 
     def prompt(self, args=None):
         """Add our information to the prompt."""

examples/03_entry_counter/03_entry_counter.py

@@ -82,8 +82,9 @@ def refresh(self, args=None):
         #
         # widget - Widget we want to render. It will be numbered automatically.
         #          Could be container if needed.
-        # callback - This callback will be called by the ListRowContainer.process_user_input() method
-        #            when a user press the number of this item. Callback will get args passed as 3rd argument.
+        # callback - This callback will be called by the ListRowContainer.process_user_input()
+        #            method when a user press the number of this item. Callback will get args
+        #            passed as 3rd argument.
         # args - Argument for callback.
         self._container.add(widget, self._push_screen_callback, self._name_spoke)
 
@@ -139,16 +140,18 @@ def input(self, args, key):
         if self._container.process_user_input(key):
             # Do not process other input if spoke is entered.
             return InputState.PROCESSED
+
         # Block continue ('c') if everything is not set.
-        elif key == Prompt.CONTINUE:
+        if key == Prompt.CONTINUE:
             if self._name_spoke and self._surname_spoke and self._password_spoke.answer:
                 return key
-            else:  # catch 'c' key if not everything set
-                return InputState.DISCARDED
-        else:
-            return key
+            # catch 'c' key if not everything set
+            return InputState.DISCARDED
+
+        return key
 
-    def _push_screen_callback(self, target_screen):
+    @staticmethod
+    def _push_screen_callback(target_screen):
         """Push target screen as new screen.
 
         Target screen is passed in as an argument in the refresh() method.

examples/05_hub_spoke/05_hub_spoke.py

@@ -80,10 +80,10 @@ def input(self, args, key):
             # This will call refresh so our new result will be processed inside of the refresh()
             # method.
             return InputState.PROCESSED_AND_REDRAW
-        else:
-            # Not input for our screen, try other default inputs. This will result in the
-            # same state as DISCARDED when no default option is used.
-            return key
+
+        # Not input for our screen, try other default inputs. This will result in the
+        # same state as DISCARDED when no default option is used.
+        return key
 
 
 if __name__ == "__main__":
@@ -100,4 +100,3 @@ def input(self, args, key):
     # Run the application. You must have some screen scheduled
     # otherwise it will end in an infinite loop.
     App.run()
-

examples/07_divider/07_divider.py

@@ -29,7 +29,7 @@
 setup_logging()
 
 
-class App(object):
+class App():
     """This is the main class for Simpleline library.
 
     Do not create instance of this class. Use this class as static!
@@ -43,7 +43,7 @@ class in your application.
     """
     __app = None
 
-    class AppPimpl(object):
+    class AppPimpl():
 
         def __init__(self, scheduler, event_loop, configuration):
             self.event_loop = event_loop
@@ -69,9 +69,9 @@ def initialize(cls, scheduler=None, event_loop=None, global_configuration=None):
         :type global_configuration: object based on class
                                     `simpleline.global_configuration.GlobalConfiguration`
         """
-        from simpleline.event_loop.main_loop import MainLoop
-        from simpleline.render.screen_scheduler import ScreenScheduler
-        from simpleline.global_configuration import GlobalConfiguration
+        from simpleline.event_loop.main_loop import MainLoop # pylint: disable=import-outside-toplevel
+        from simpleline.render.screen_scheduler import ScreenScheduler # pylint: disable=import-outside-toplevel
+        from simpleline.global_configuration import GlobalConfiguration # pylint: disable=import-outside-toplevel
 
         if event_loop is None:
             event_loop = MainLoop()
@@ -86,7 +86,7 @@ def initialize(cls, scheduler=None, event_loop=None, global_configuration=None):
 
     @classmethod
     def _post_init(cls):
-        from simpleline.input.input_threading import InputThreadManager
+        from simpleline.input.input_threading import InputThreadManager # pylint: disable=import-outside-toplevel
         # FIXME: This should be done by more general way not by calling exact class here.
         # Create new instance of InputThreadManager because it needs new event loop
         InputThreadManager.create_new_instance()
@@ -99,8 +99,8 @@ def is_initialized(cls):
         """
         if cls.__app is None:
             return False
-        else:
-            return True
+
+        return True
 
     @classmethod
     def get_scheduler(cls):

simpleline/__init__.py

@@ -92,7 +92,9 @@ def enqueue_signal(self, signal):
         :param signal: Signal which you want to add to the event queue for processing.
         :type signal: Instance based on AbstractEvent class.
         """
-        log.debug("New signal %s enqueued with source %s", signal, signal.source.__class__.__name__)
+        log.debug("New signal %s enqueued with source %s",
+                  signal,
+                  signal.source.__class__.__name__)
 
     @abstractmethod
     def run(self):
@@ -132,14 +134,14 @@ def close_loop(self):
     def process_signals(self, return_after=None):
         """This method processes incoming async messages.
 
-        Process signals enqueued by the `self.enqueue_signal()` method. Call handlers registered to the signals by
-        the `self.register_signal_handler()` method.
+        Process signals enqueued by the `self.enqueue_signal()` method. Call handlers
+        registered to the signals by the `self.register_signal_handler()` method.
 
         When `return_after` is specified then wait to the point when this signal is processed.
         NO warranty that this method will return immediately after the signal was processed!
 
-        Without `return_after` parameter this method will return after all queued signals with the highest priority
-        will be processed.
+        Without `return_after` parameter this method will return after all queued signals
+        with the highest priority will be processed.
 
         The method is NOT thread safe!
 
@@ -161,8 +163,8 @@ def set_quit_callback(self, callback, args=None):
     def kill_app_with_traceback(self, exception_signal, data=None):
         """Print exception and screen stack and kill the application.
 
-        :param exception_signal: ExceptionSignal encapsulating the original exception which will be passed to
-                                 the sys.excepthook method.
+        :param exception_signal: ExceptionSignal encapsulating the original exception which
+                                 will be passed to the sys.excepthook method.
         :type exception_signal: Instance of `simpleline.event_loop.signals.ExceptionSignal` class.
 
         :param data: To be usable as signal handler.
@@ -171,7 +173,7 @@ def kill_app_with_traceback(self, exception_signal, data=None):
         log.debug("Unhandled error in handler raised:")
         sys.excepthook(*exception_signal.exception_info)
 
-        from simpleline import App
+        from simpleline import App # pylint: disable=import-outside-toplevel
         stack_dump = App.get_scheduler().dump_stack()
         print("")
         print(stack_dump)
@@ -180,7 +182,8 @@ def kill_app_with_traceback(self, exception_signal, data=None):
         log.debug("Killing application!")
         sys.exit(1)
 
-    def _create_event_handler(self, callback, data):
+    @staticmethod
+    def _create_event_handler(callback, data):
         """Create event handler data object and return it."""
         return EventHandler(callback=callback, data=data)
 
@@ -214,7 +217,7 @@ def _check_if_signal_processed(self, wait_on_signal, unique_id):
         return self._processed_signals.check_ticket(wait_on_signal.__name__, unique_id)
 
 
-class EventHandler(object):
+class EventHandler():
     """Data class to save event handlers."""
 
     def __init__(self, callback, data):
@@ -250,7 +253,8 @@ def priority(self):
         """Priority of this event.
 
         Values less than 0 denote higher priorities. Values greater than 0 denote lower priorities.
-        Events from high priority sources are always processed before events from lower priority sources.
+        Events from high priority sources are always processed before events from lower priority
+        sources.
         """
         return self._priority
 

simpleline/event_loop/__init__.py

@@ -36,7 +36,7 @@ class EventQueueError(SimplelineError):
     """
 
 
-class EventQueue(object):
+class EventQueue():
     """Class for managing signal queue.
 
     Responsibilities of this class are:
@@ -68,7 +68,8 @@ def enqueue(self, signal):
     def enqueue_if_source_belongs(self, signal, source):
         """Enqueue signal to this queue if the signal source belongs to this queue.
 
-        Enqueue the `signal` only if the `source` belongs to this queue. See the `add_source()` method.
+        Enqueue the `signal` only if the `source` belongs to this queue.
+        See the `add_source()` method.
 
         :param signal: Signal which should be enqueued to this queue.
         :type signal: Signal class based on `simpleline.event_loop.signals.AbstractSignal`.
@@ -80,8 +81,8 @@ def enqueue_if_source_belongs(self, signal, source):
         if self.contains_source(source):
             self._queue.put(signal)
             return True
-        else:
-            return False
+
+        return False
 
     def get(self):
         """Return enqueued signal with the highest priority.
@@ -106,9 +107,9 @@ def get_top_event_if_priority(self, priority):
         event = self._queue.get()
         if event.priority == priority:
             return event
-        else:
-            self._queue.put(event)
-            return None
+
+        self._queue.put(event)
+        return None
 
     def add_source(self, signal_source):
         """Add new source of signals to this queue.

simpleline/event_loop/event_queue.py

@@ -21,17 +21,17 @@
 #
 # Author(s): Jiri Konecny <[email protected]>
 #
-
 from collections import namedtuple
 
+import gi
+
 from simpleline.event_loop import AbstractEventLoop, ExitMainLoop
 from simpleline.event_loop.signals import ExceptionSignal
+from simpleline.logging import get_simpleline_logger
 
-import gi
 gi.require_version("GLib", "2.0")
 
-from gi.repository import GLib
-from simpleline.logging import get_simpleline_logger
+from gi.repository import GLib # pylint: disable=wrong-import-order, wrong-import-position
 
 log = get_simpleline_logger()
 
@@ -92,9 +92,9 @@ def _register_handlers_to_loop(self, event_loop, signal):
         context = event_loop.get_context()
         handlers = []
 
-        if type(signal) in self._handlers:
+        if type(signal) in self._handlers: # pylint: disable=unidiomatic-typecheck
             handlers = self._handlers[type(signal)]
-        elif type(signal) is ExceptionSignal:
+        elif isinstance(signal, ExceptionSignal):
             handler_data = self._create_event_handler(self.kill_app_with_traceback, None)
             handlers = [handler_data]
 
@@ -188,14 +188,14 @@ def close_loop(self):
     def process_signals(self, return_after=None):
         """This method processes incoming async messages.
 
-        Process signals enqueued by the `self.enqueue_signal()` method. Call handlers registered to the signals by
-        the `self.register_signal_handler()` method.
+        Process signals en-queued by the `self.enqueue_signal()` method. Call handlers registered
+                        to the signals by the `self.register_signal_handler()` method.
 
         When `return_after` is specified then wait to the point when this signal is processed.
         NO warranty that this method will return immediately after the signal was processed!
 
-        Without `return_after` parameter this method will return after all queued signals with the highest priority
-        will be processed.
+        Without `return_after` parameter this method will return after all queued signals with
+        the highest priority will be processed.
 
         The method is NOT thread safe!
 
@@ -208,22 +208,23 @@ def process_signals(self, return_after=None):
         if return_after is not None:
             ticket_id = self._register_wait_on_signal(return_after)
 
-            while not self._check_if_signal_processed(return_after, ticket_id) and not self._force_quit:
+            while not self._check_if_signal_processed(return_after, ticket_id) and \
+                  not self._force_quit:
                 self._iterate_event_loop(loop_data.loop)
         else:
             self._iterate_event_loop(loop_data.loop)
 
-    def _iterate_event_loop(self, event_loop):
+    @staticmethod
+    def _iterate_event_loop(event_loop):
         context = event_loop.get_context()
         # This is useful for tests
         wait_on_timeout = False
         context.iteration(wait_on_timeout)
 
 
-class EventLoopData(object):
+class EventLoopData():
 
     def __init__(self, loop):
         super().__init__()
         self.loop = loop
         self.sources = set()
-