[master 2/30] Change configparser and queue imports (#1014220)

M4rtinK installerbot-noreply at redhat.com
Mon Jun 1 14:04:19 UTC 2015


From: Martin Kolman <mkolman at redhat.com>

Queue has been renamed to queue and ConfigParser to
configparser in Python 3.

Also make sure that we don't shadow the queue module by renaming
all "queue" variables to "queue_instance".
---
 pyanaconda/packaging/__init__.py     |  6 +++---
 pyanaconda/packaging/dnfpayload.py   | 22 +++++++++----------
 pyanaconda/product.py                |  4 ++--
 pyanaconda/queuefactory.py           |  4 ++--
 pyanaconda/ui/gui/hubs/__init__.py   |  4 ++--
 pyanaconda/ui/gui/hubs/progress.py   |  4 ++--
 pyanaconda/ui/gui/utils.py           | 41 ++++++++++++++++++------------------
 pyanaconda/ui/tui/__init__.py        |  8 +++----
 pyanaconda/ui/tui/simpleline/base.py | 39 +++++++++++++++++-----------------
 pyanaconda/ui/tui/spokes/progress.py |  4 ++--
 10 files changed, 69 insertions(+), 67 deletions(-)

diff --git a/pyanaconda/packaging/__init__.py b/pyanaconda/packaging/__init__.py
index 57cc7d7..f93b1f1 100644
--- a/pyanaconda/packaging/__init__.py
+++ b/pyanaconda/packaging/__init__.py
@@ -29,7 +29,7 @@
 """
 import os
 import requests
-import ConfigParser
+import configparser
 import shutil
 from glob import glob
 from fnmatch import fnmatch
@@ -387,14 +387,14 @@ def _getReleaseVersion(self, url):
             proxy = None
         treeinfo = self._getTreeInfo(url, proxy, not flags.noverifyssl)
         if treeinfo:
-            c = ConfigParser.ConfigParser()
+            c = configparser.ConfigParser()
             c.read(treeinfo)
             try:
                 # Trim off any -Alpha or -Beta
                 version = re.match(VERSION_DIGITS, c.get("general", "version")).group(1)
             except AttributeError:
                 version = "rawhide"
-            except ConfigParser.Error:
+            except configparser.Error:
                 pass
 
         log.debug("got a release version of %s", version)
diff --git a/pyanaconda/packaging/dnfpayload.py b/pyanaconda/packaging/dnfpayload.py
index a14725e..7212ea6 100644
--- a/pyanaconda/packaging/dnfpayload.py
+++ b/pyanaconda/packaging/dnfpayload.py
@@ -27,7 +27,7 @@
 from pyanaconda.i18n import _
 from pyanaconda.progress import progressQ
 
-import ConfigParser
+import configparser
 import collections
 import itertools
 import logging
@@ -114,9 +114,9 @@ def reasonable_mpoint(mpoint):
                   reverse=True)[0][0]
 
 class PayloadRPMDisplay(dnf.callback.LoggingTransactionDisplay):
-    def __init__(self, queue):
+    def __init__(self, queue_instance):
         super(PayloadRPMDisplay, self).__init__()
-        self._queue = queue
+        self._queue = queue_instance
         self._last_ts = None
         self.cnt = 0
 
@@ -171,14 +171,14 @@ def start(self, total_files, total_size):
         self.total_files = total_files
         self.total_size = Size(total_size)
 
-def do_transaction(base, queue):
+def do_transaction(base, queue_instance):
     try:
-        display = PayloadRPMDisplay(queue)
+        display = PayloadRPMDisplay(queue_instance)
         base.do_transaction(display=display)
     except BaseException as e:
         log.error('The transaction process has ended abruptly')
         log.info(e)
-        queue.put(('quit', str(e)))
+        queue_instance.put(('quit', str(e)))
 
 class DNFPayload(packaging.PackagePayload):
     def __init__(self, data):
@@ -642,16 +642,16 @@ def install(self):
         pre_msg = _("Preparing transaction from installation source")
         progressQ.send_message(pre_msg)
 
-        queue = multiprocessing.Queue()
+        queue_instance = multiprocessing.Queue()
         process = multiprocessing.Process(target=do_transaction,
-                                          args=(self._base, queue))
+                                          args=(self._base, queue_instance))
         process.start()
-        (token, msg) = queue.get()
+        (token, msg) = queue_instance.get()
         while token not in ('post', 'quit'):
             if token == 'install':
                 msg = _("Installing %s") % msg
                 progressQ.send_message(msg)
-            (token, msg) = queue.get()
+            (token, msg) = queue_instance.get()
 
         if token == 'quit':
             _failure_limbo()
@@ -732,7 +732,7 @@ def updateBaseRepo(self, fallback=True, checkmount=True):
             try:
                 self._base.conf.releasever = self._getReleaseVersion(url)
                 log.debug("releasever from %s is %s", url, self._base.conf.releasever)
-            except ConfigParser.MissingSectionHeaderError as e:
+            except configparser.MissingSectionHeaderError as e:
                 log.error("couldn't set releasever from base repo (%s): %s",
                           method.method, e)
 
diff --git a/pyanaconda/product.py b/pyanaconda/product.py
index bc6b617..4b7b761 100644
--- a/pyanaconda/product.py
+++ b/pyanaconda/product.py
@@ -17,14 +17,14 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-import ConfigParser
+import configparser
 import os
 
 from pyanaconda.i18n import _
 
 # First, load in the defaults.  In order of precedence:  contents of
 # .buildstamp, environment, stupid last ditch hardcoded defaults.
-config = ConfigParser.ConfigParser()
+config = configparser.ConfigParser()
 config.add_section("Main")
 config.set("Main", "Arch", os.environ.get("ANACONDA_PRODUCTARCH", os.uname()[4]))
 config.set("Main", "BugURL", os.environ.get("ANACONDA_BUGURL", "your distribution provided bug reporting tool"))
diff --git a/pyanaconda/queuefactory.py b/pyanaconda/queuefactory.py
index 31f6a54..a027eb3 100644
--- a/pyanaconda/queuefactory.py
+++ b/pyanaconda/queuefactory.py
@@ -18,7 +18,7 @@
 #
 # Author(s): Chris Lumens <clumens at redhat.com>
 
-import Queue
+import queue
 from pyanaconda.iutil import lowerASCII, upperASCII
 
 class QueueFactory(object):
@@ -48,7 +48,7 @@ def __init__(self, name):
         self.__counter = 0
         self.__names = []
 
-        self.q = Queue.Queue()
+        self.q = queue.Queue()
 
     def _makeMethod(self, constant, methodName, argc):
         def __method(*args):
diff --git a/pyanaconda/ui/gui/hubs/__init__.py b/pyanaconda/ui/gui/hubs/__init__.py
index e266b96..1c8b276 100644
--- a/pyanaconda/ui/gui/hubs/__init__.py
+++ b/pyanaconda/ui/gui/hubs/__init__.py
@@ -246,7 +246,7 @@ def _updateContinueButton(self):
 
     def _update_spokes(self):
         from pyanaconda.ui.communication import hubQ
-        import Queue
+        import queue
 
         q = hubQ.q
 
@@ -260,7 +260,7 @@ def _update_spokes(self):
         while True:
             try:
                 (code, args) = q.get(False)
-            except Queue.Empty:
+            except queue.Empty:
                 break
 
             # The first argument to all codes is the name of the spoke we are
diff --git a/pyanaconda/ui/gui/hubs/progress.py b/pyanaconda/ui/gui/hubs/progress.py
index cdd12ff..7965922 100644
--- a/pyanaconda/ui/gui/hubs/progress.py
+++ b/pyanaconda/ui/gui/hubs/progress.py
@@ -84,7 +84,7 @@ def _start_ransom_notes(self):
 
     def _update_progress(self, callback=None):
         from pyanaconda.progress import progressQ
-        import Queue
+        import queue
 
         q = progressQ.q
 
@@ -94,7 +94,7 @@ def _update_progress(self, callback=None):
             # the progress bar.  If there's no message, don't error out.
             try:
                 (code, args) = q.get(False)
-            except Queue.Empty:
+            except queue.Empty:
                 break
 
             if code == progressQ.PROGRESS_CODE_INIT:
diff --git a/pyanaconda/ui/gui/utils.py b/pyanaconda/ui/gui/utils.py
index 6f531db..619874d 100644
--- a/pyanaconda/ui/gui/utils.py
+++ b/pyanaconda/ui/gui/utils.py
@@ -27,7 +27,7 @@
 
 from pyanaconda.constants import NOTICEABLE_FREEZE
 from gi.repository import Gdk, Gtk, GLib
-import Queue
+import queue
 import time
 import threading
 
@@ -54,25 +54,25 @@ def gtk_action_wait(func):
        thread and returns the ret value after the decorated method finishes.
     """
 
-    queue = Queue.Queue()
+    queue_instance = queue.Queue()
 
-    def _idle_method(queue, args, kwargs):
+    def _idle_method(queue_instance, args, kwargs):
         """This method contains the code for the main loop to execute.
         """
-        ret = func(*args, **kwargs)
-        queue.put(ret)
+        ret = func(*args)
+        queue_instance.put(ret)
         return False
 
     def _call_method(*args, **kwargs):
         """The new body for the decorated method. If needed, it uses closure
-           bound queue variable which is valid until the reference to this
+           bound queue_instance variable which is valid until the reference to this
            method is destroyed."""
         if threadMgr.in_main_thread():
             # nothing special has to be done in the main thread
             return func(*args, **kwargs)
 
-        GLib.idle_add(_idle_method, queue, args, kwargs)
-        return queue.get()
+        GLib.idle_add(_idle_method, queue_instance, args, kwargs)
+        return queue_instance.get()
 
     return _call_method
 
@@ -159,17 +159,18 @@ def gtk_batch_map(action, items, args=(), pre_func=None, batch_size=1):
 
     assert(not threadMgr.in_main_thread())
 
-    def preprocess(queue):
+    def preprocess(queue_instance):
         if pre_func:
             for item in items:
-                queue.put(pre_func(item))
+                queue_instance.put(pre_func(item))
         else:
             for item in items:
-                queue.put(item)
+                queue_instance.put(item)
 
-        queue.put(TERMINATOR)
+        queue_instance.put(TERMINATOR)
 
-    def process_one_batch((queue, action, done_event)):
+    def process_one_batch(arguments):
+        (queue_instance, action, done_event) = arguments
         tstamp_start = time.time()
         tstamp = time.time()
 
@@ -177,7 +178,7 @@ def process_one_batch((queue, action, done_event)):
         while tstamp - tstamp_start < NOTICEABLE_FREEZE:
             for _i in range(batch_size):
                 try:
-                    action_item = queue.get_nowait()
+                    action_item = queue_instance.get_nowait()
                     if action_item is TERMINATOR:
                         # all items processed, tell we are finished and return
                         done_event.set()
@@ -185,8 +186,8 @@ def process_one_batch((queue, action, done_event)):
                     else:
                         # run action on the item
                         action(action_item, *args)
-                except Queue.Empty:
-                    # empty queue, reschedule to run later
+                except queue.Empty:
+                    # empty queue_instance, reschedule to run later
                     return True
 
             tstamp = time.time()
@@ -194,18 +195,18 @@ def process_one_batch((queue, action, done_event)):
         # out of time but something left, reschedule to run again later
         return True
 
-    item_queue = Queue.Queue()
+    item_queue_instance = queue.Queue()
     done_event = threading.Event()
 
     # we don't want to log the whole list, type and address is enough
     log.debug("Starting applying %s on %s", action, object.__repr__(items))
 
-    # start a thread putting preprocessed items into the queue
+    # start a thread putting preprocessed items into the queue_instance
     threadMgr.add(AnacondaThread(prefix="AnaGtkBatchPre",
                                  target=preprocess,
-                                 args=(item_queue,)))
+                                 args=(item_queue_instance,)))
 
-    GLib.idle_add(process_one_batch, (item_queue, action, done_event))
+    GLib.idle_add(process_one_batch, (item_queue_instance, action, done_event))
     done_event.wait()
     log.debug("Finished applying %s on %s", action, object.__repr__(items))
 
diff --git a/pyanaconda/ui/tui/__init__.py b/pyanaconda/ui/tui/__init__.py
index 8b325cb..e5ed6ac 100644
--- a/pyanaconda/ui/tui/__init__.py
+++ b/pyanaconda/ui/tui/__init__.py
@@ -31,7 +31,7 @@
 import os
 import sys
 import site
-import Queue
+import queue as queue
 import meh.ui.text
 import logging
 log = logging.getLogger("anaconda")
@@ -139,7 +139,7 @@ def setup(self, data):
            This method must be provided by all subclasses.
         """
         self._app = tui.App(self.productTitle, yes_or_no_question=YesNoDialog,
-                            quit_message=self.quitMessage, queue=hubQ.q)
+                            quit_message=self.quitMessage, queue_instance=hubQ.q)
 
         # tell python-meh it should use our raw_input
         self._meh_interface.set_io_handler(meh.ui.text.IOHandler(in_func=self._app.raw_input))
@@ -195,7 +195,7 @@ def _send_show_message(self, msg_fn, args, ret_queue):
         :type args: any
         :param ret_queue: the queue which the return value of the message dialog
                           function should be put
-        :type ret_queue: a Queue.Queue instance
+        :type ret_queue: a queue.Queue instance
 
         """
 
@@ -238,7 +238,7 @@ def _show_message_in_main_thread(self, msg_fn, args):
             return msg_fn(*args)
         else:
             # create a queue for the result returned by the function
-            ret_queue = Queue.Queue()
+            ret_queue = queue.Queue()
 
             # request the function to be called in the main thread
             self._send_show_message(msg_fn, args, ret_queue)
diff --git a/pyanaconda/ui/tui/simpleline/base.py b/pyanaconda/ui/tui/simpleline/base.py
index 991f659..211b60e 100644
--- a/pyanaconda/ui/tui/simpleline/base.py
+++ b/pyanaconda/ui/tui/simpleline/base.py
@@ -22,11 +22,12 @@
 __all__ = ["App", "UIScreen", "Widget"]
 
 import sys
-import Queue
+import queue
 import getpass
 import threading
 import types
 import functools
+import queue
 from pyanaconda.threads import threadMgr, AnacondaThread
 from pyanaconda.ui.communication import hubQ
 from pyanaconda import constants, iutil
@@ -35,8 +36,8 @@
 RAW_INPUT_LOCK = threading.Lock()
 
 
-def send_exception(queue, ex):
-    queue.put((hubQ.HUB_CODE_EXCEPTION, [ex]))
+def send_exception(queue_instance, ex):
+    queue_instance.put((hubQ.HUB_CODE_EXCEPTION, [ex]))
 
 
 class ExitMainLoop(Exception):
@@ -67,7 +68,7 @@ class App(object):
     STOP_MAINLOOP = False
     NOP = None
 
-    def __init__(self, title, yes_or_no_question=None, width=80, queue=None,
+    def __init__(self, title, yes_or_no_question=None, width=80, queue_instance=None,
                  quit_message=None):
         """
         :param title: application title for whenever we need to display app name
@@ -88,10 +89,10 @@ def __init__(self, title, yes_or_no_question=None, width=80, queue=None,
         self.quit_message = quit_message or N_(u"Do you really want to quit?")
 
         # async control queue
-        if queue:
-            self.queue = queue
+        if queue_instance:
+            self.queue_instance = queue_instance
         else:
-            self.queue = Queue.Queue()
+            self.queue_instance = queue.Queue()
 
         # event handlers
         # key: event id
@@ -128,13 +129,13 @@ def register_event_handler(self, event, callback, data=None):
             self._handlers[event] = []
         self._handlers[event].append((callback, data))
 
-    def _thread_input(self, queue, prompt, hidden):
+    def _thread_input(self, queue_instance, prompt, hidden):
         """This method is responsible for interruptible user input. It is expected
         to be used in a thread started on demand by the App class and returns the
         input via the communication Queue.
 
-        :param queue: communication queue to be used
-        :type queue: Queue.Queue instance
+        :param queue_instance: communication queue_instance to be used
+        :type queue_instance: queue.Queue instance
 
         :param prompt: prompt to be displayed
         :type prompt: str
@@ -164,7 +165,7 @@ def _thread_input(self, queue, prompt, hidden):
                 finally:
                     RAW_INPUT_LOCK.release()
 
-        queue.put((hubQ.HUB_CODE_INPUT, [data]))
+        queue_instance.put((hubQ.HUB_CODE_INPUT, [data]))
 
     def switch_screen(self, ui, args=None):
         """Schedules a screen to replace the current one.
@@ -289,7 +290,7 @@ def _do_redraw(self):
             except ExitMainLoop:
                 raise
             except Exception:    # pylint: disable=broad-except
-                send_exception(self.queue, sys.exc_info())
+                send_exception(self.queue_instance, sys.exc_info())
                 return False
 
         else:
@@ -348,7 +349,7 @@ def _mainloop(self):
                 except ExitMainLoop:
                     raise
                 except Exception:    # pylint: disable=broad-except
-                    send_exception(self.queue, sys.exc_info())
+                    send_exception(self.queue_instance, sys.exc_info())
                     continue
 
                 # None means prompt handled the input by itself
@@ -385,7 +386,7 @@ def _mainloop(self):
 
     def process_events(self, return_at=None):
         """This method processes incoming async messages and returns
-           when a specific message is encountered or when the queue
+           when a specific message is encountered or when the queue_instance
            is empty.
 
            If return_at message was specified, the received
@@ -394,8 +395,8 @@ def process_events(self, return_at=None):
            If the message does not fit return_at, but handlers are
            defined then it processes all handlers for this message
         """
-        while return_at or not self.queue.empty():
-            event = self.queue.get()
+        while return_at or not self.queue_instance.empty():
+            event = self.queue_instance.get()
             if event[0] == return_at:
                 return event
             elif event[0] in self._handlers:
@@ -405,7 +406,7 @@ def process_events(self, return_at=None):
                     except ExitMainLoop:
                         raise
                     except Exception:    # pylint: disable=broad-except
-                        send_exception(self.queue, sys.exc_info())
+                        send_exception(self.queue_instance, sys.exc_info())
 
     def raw_input(self, prompt, hidden=False):
         """This method reads one input from user. Its basic form has only one
@@ -413,7 +414,7 @@ def raw_input(self, prompt, hidden=False):
 
         input_thread = AnacondaThread(prefix=constants.THREAD_INPUT_BASENAME,
                                       target=self._thread_input,
-                                      args=(self.queue, prompt, hidden))
+                                      args=(self.queue_instance, prompt, hidden))
         input_thread.daemon = True
         threadMgr.add(input_thread)
         event = self.process_events(return_at=hubQ.HUB_CODE_INPUT)
@@ -443,7 +444,7 @@ def input(self, args, key):
             except ExitMainLoop:
                 raise
             except Exception:    # pylint: disable=broad-except
-                send_exception(self.queue, sys.exc_info())
+                send_exception(self.queue_instance, sys.exc_info())
                 return False
 
         # global refresh command
diff --git a/pyanaconda/ui/tui/spokes/progress.py b/pyanaconda/ui/tui/spokes/progress.py
index ac42622..9e94122 100644
--- a/pyanaconda/ui/tui/spokes/progress.py
+++ b/pyanaconda/ui/tui/spokes/progress.py
@@ -52,7 +52,7 @@ def _update_progress(self):
         """Handle progress updates from install thread."""
 
         from pyanaconda.progress import progressQ
-        import Queue
+        import queue
 
         q = progressQ.q
 
@@ -67,7 +67,7 @@ def _update_progress(self):
                 try:
                     (code, args) = q.get(timeout=1)
                     break
-                except Queue.Empty:
+                except queue.Empty:
                     pass
                 finally:
                     self.app.process_events()


-- 
To view this commit on github, visit https://github.com/rhinstaller/anaconda/commit/0ae58f4c674688836ebea2e5324148dea4fecd1e


More information about the anaconda-patches mailing list