STY: Giant comma spacing fixup.

Run the 2to3 ws_comma fixer on *.py files. Some lines are now too long
and will need to be broken at some point. OTOH, some lines were already
too long and need to be broken at some point. Now seems as good a time
as any to do this with open PRs at a minimum.

1 files changed, 53 insertions, 53 deletions

diff --git a/numpy/_import_tools.py b/numpy/_import_tools.py
index ba9e021c7..3343f6c05 100644
--- a/numpy/_import_tools.py
+++ b/numpy/_import_tools.py
@@ -15,14 +15,14 @@ class PackageLoader(object):
         else:
             _level = 1
         self.parent_frame = frame = sys._getframe(_level)
-        self.parent_name = eval('__name__',frame.f_globals,frame.f_locals)
-        parent_path = eval('__path__',frame.f_globals,frame.f_locals)
+        self.parent_name = eval('__name__', frame.f_globals, frame.f_locals)
+        parent_path = eval('__path__', frame.f_globals, frame.f_locals)
         if isinstance(parent_path, str):
             parent_path = [parent_path]
         self.parent_path = parent_path
         if '__all__' not in frame.f_locals:
-            exec('__all__ = []',frame.f_globals,frame.f_locals)
-        self.parent_export_names = eval('__all__',frame.f_globals,frame.f_locals)
+            exec('__all__ = []', frame.f_globals, frame.f_locals)
+        self.parent_export_names = eval('__all__', frame.f_globals, frame.f_locals)
 
         self.info_modules = {}
         self.imported_packages = []
@@ -32,17 +32,17 @@ class PackageLoader(object):
         """ Return list of (package name,info.py file) from parent_path subdirectories.
         """
         from glob import glob
-        files = glob(os.path.join(parent_path,package_dir,'info.py'))
-        for info_file in glob(os.path.join(parent_path,package_dir,'info.pyc')):
+        files = glob(os.path.join(parent_path, package_dir, 'info.py'))
+        for info_file in glob(os.path.join(parent_path, package_dir, 'info.pyc')):
             if info_file[:-1] not in files:
                 files.append(info_file)
         info_files = []
         for info_file in files:
             package_name = os.path.dirname(info_file[len(parent_path)+1:])\
-                           .replace(os.sep,'.')
+                           .replace(os.sep, '.')
             if parent_package:
                 package_name = parent_package + '.' + package_name
-            info_files.append((package_name,info_file))
+            info_files.append((package_name, info_file))
             info_files.extend(self._get_info_files('*',
                                                    os.path.dirname(info_file),
                                                    package_name))
@@ -57,7 +57,7 @@ class PackageLoader(object):
 
         if packages is None:
             for path in self.parent_path:
-                info_files.extend(self._get_info_files('*',path))
+                info_files.extend(self._get_info_files('*', path))
         else:
             for package_name in packages:
                 package_dir = os.path.join(*package_name.split('.'))
@@ -73,30 +73,30 @@ class PackageLoader(object):
                     except ImportError as msg:
                         self.warn('No scipy-style subpackage %r found in %s. '\
                                   'Ignoring: %s'\
-                                  % (package_name,':'.join(self.parent_path), msg))
+                                  % (package_name, ':'.join(self.parent_path), msg))
 
-        for package_name,info_file in info_files:
+        for package_name, info_file in info_files:
             if package_name in info_modules:
                 continue
             fullname = self.parent_name +'.'+ package_name
             if info_file[-1]=='c':
-                filedescriptor = ('.pyc','rb',2)
+                filedescriptor = ('.pyc', 'rb', 2)
             else:
-                filedescriptor = ('.py','U',1)
+                filedescriptor = ('.py', 'U', 1)
 
             try:
                 info_module = imp.load_module(fullname+'.info',
-                                              open(info_file,filedescriptor[1]),
+                                              open(info_file, filedescriptor[1]),
                                               info_file,
                                               filedescriptor)
             except Exception as msg:
                 self.error(msg)
                 info_module = None
 
-            if info_module is None or getattr(info_module,'ignore',False):
-                info_modules.pop(package_name,None)
+            if info_module is None or getattr(info_module, 'ignore', False):
+                info_modules.pop(package_name, None)
             else:
-                self._init_info_modules(getattr(info_module,'depends',[]))
+                self._init_info_modules(getattr(info_module, 'depends', []))
                 info_modules[package_name] = info_module
 
         return
@@ -107,8 +107,8 @@ class PackageLoader(object):
         """
 
         depend_dict = {}
-        for name,info_module in self.info_modules.items():
-            depend_dict[name] = getattr(info_module,'depends',[])
+        for name, info_module in self.info_modules.items():
+            depend_dict[name] = getattr(info_module, 'depends', [])
         package_names = []
 
         for name in depend_dict.keys():
@@ -165,10 +165,10 @@ class PackageLoader(object):
      """
         frame = self.parent_frame
         self.info_modules = {}
-        if options.get('force',False):
+        if options.get('force', False):
             self.imported_packages = []
-        self.verbose = verbose = options.get('verbose',-1)
-        postpone = options.get('postpone',None)
+        self.verbose = verbose = options.get('verbose', -1)
+        postpone = options.get('postpone', None)
         self._init_info_modules(packages or None)
 
         self.log('Imports to %r namespace\n----------------------------'\
@@ -178,13 +178,13 @@ class PackageLoader(object):
             if package_name in self.imported_packages:
                 continue
             info_module = self.info_modules[package_name]
-            global_symbols = getattr(info_module,'global_symbols',[])
-            postpone_import = getattr(info_module,'postpone_import',False)
+            global_symbols = getattr(info_module, 'global_symbols', [])
+            postpone_import = getattr(info_module, 'postpone_import', False)
             if (postpone and not global_symbols) \
                    or (postpone_import and postpone is not None):
                 continue
 
-            old_object = frame.f_locals.get(package_name,None)
+            old_object = frame.f_locals.get(package_name, None)
 
             cmdstr = 'import '+package_name
             if self._execcmd(cmdstr):
@@ -195,7 +195,7 @@ class PackageLoader(object):
                 new_object = frame.f_locals.get(package_name)
                 if old_object is not None and old_object is not new_object:
                     self.warn('Overwriting %s=%s (was %s)' \
-                              % (package_name,self._obj2repr(new_object),
+                              % (package_name, self._obj2repr(new_object),
                                  self._obj2repr(old_object)))
 
             if '.' not in package_name:
@@ -205,10 +205,10 @@ class PackageLoader(object):
                 if symbol=='*':
                     symbols = eval('getattr(%s,"__all__",None)'\
                                    % (package_name),
-                                   frame.f_globals,frame.f_locals)
+                                   frame.f_globals, frame.f_locals)
                     if symbols is None:
                         symbols = eval('dir(%s)' % (package_name),
-                                       frame.f_globals,frame.f_locals)
+                                       frame.f_globals, frame.f_locals)
                         symbols = [s for s in symbols if not s.startswith('_')]
                 else:
                     symbols = [symbol]
@@ -224,11 +224,11 @@ class PackageLoader(object):
                     continue
 
                 if verbose!=-1:
-                    for s,old_object in old_objects.items():
+                    for s, old_object in old_objects.items():
                         new_object = frame.f_locals[s]
                         if new_object is not old_object:
                             self.warn('Overwriting %s=%s (was %s)' \
-                                      % (s,self._obj2repr(new_object),
+                                      % (s, self._obj2repr(new_object),
                                          self._obj2repr(old_object)))
 
                 if symbol=='*':
@@ -238,60 +238,60 @@ class PackageLoader(object):
 
         return
 
-    def _execcmd(self,cmdstr):
+    def _execcmd(self, cmdstr):
         """ Execute command in parent_frame."""
         frame = self.parent_frame
         try:
-            exec (cmdstr, frame.f_globals,frame.f_locals)
+            exec (cmdstr, frame.f_globals, frame.f_locals)
         except Exception as msg:
-            self.error('%s -> failed: %s' % (cmdstr,msg))
+            self.error('%s -> failed: %s' % (cmdstr, msg))
             return True
         else:
             self.log('%s -> success' % (cmdstr))
         return
 
-    def _obj2repr(self,obj):
+    def _obj2repr(self, obj):
         """ Return repr(obj) with"""
-        module = getattr(obj,'__module__',None)
-        file = getattr(obj,'__file__',None)
+        module = getattr(obj, '__module__', None)
+        file = getattr(obj, '__file__', None)
         if module is not None:
             return repr(obj) + ' from ' + module
         if file is not None:
             return repr(obj) + ' from ' + file
         return repr(obj)
 
-    def log(self,mess):
+    def log(self, mess):
         if self.verbose>1:
             print(str(mess), file=sys.stderr)
-    def warn(self,mess):
+    def warn(self, mess):
         if self.verbose>=0:
             print(str(mess), file=sys.stderr)
-    def error(self,mess):
+    def error(self, mess):
         if self.verbose!=-1:
             print(str(mess), file=sys.stderr)
 
     def _get_doc_title(self, info_module):
         """ Get the title from a package info.py file.
         """
-        title = getattr(info_module,'__doc_title__',None)
+        title = getattr(info_module, '__doc_title__', None)
         if title is not None:
             return title
-        title = getattr(info_module,'__doc__',None)
+        title = getattr(info_module, '__doc__', None)
         if title is not None:
-            title = title.lstrip().split('\n',1)[0]
+            title = title.lstrip().split('\n', 1)[0]
             return title
         return '* Not Available *'
 
     def _format_titles(self,titles,colsep='---'):
         display_window_width = 70 # How to determine the correct value in runtime??
-        lengths = [len(name)-name.find('.')-1 for (name,title) in titles]+[0]
+        lengths = [len(name)-name.find('.')-1 for (name, title) in titles]+[0]
         max_length = max(lengths)
         lines = []
-        for (name,title) in titles:
+        for (name, title) in titles:
             name = name[name.find('.')+1:]
             w = max_length - len(name)
             words = title.split()
-            line = '%s%s %s' % (name,w*' ',colsep)
+            line = '%s%s %s' % (name, w*' ', colsep)
             tab = len(line) * ' '
             while words:
                 word = words.pop(0)
@@ -313,14 +313,14 @@ class PackageLoader(object):
         titles = []
         symbols = []
         for package_name, info_module in self.info_modules.items():
-            global_symbols = getattr(info_module,'global_symbols',[])
+            global_symbols = getattr(info_module, 'global_symbols', [])
             fullname = self.parent_name +'.'+ package_name
             note = ''
             if fullname not in sys.modules:
                 note = ' [*]'
-            titles.append((fullname,self._get_doc_title(info_module) + note))
+            titles.append((fullname, self._get_doc_title(info_module) + note))
             if global_symbols:
-                symbols.append((package_name,', '.join(global_symbols)))
+                symbols.append((package_name, ', '.join(global_symbols)))
 
         retstr = self._format_titles(titles) +\
                '\n  [*] - using a package requires explicit import (see pkgload)'
@@ -329,20 +329,20 @@ class PackageLoader(object):
         if symbols:
             retstr += """\n\nGlobal symbols from subpackages"""\
                       """\n-------------------------------\n""" +\
-                      self._format_titles(symbols,'-->')
+                      self._format_titles(symbols, '-->')
 
         return retstr
 
 class PackageLoaderDebug(PackageLoader):
-    def _execcmd(self,cmdstr):
+    def _execcmd(self, cmdstr):
         """ Execute command in parent_frame."""
         frame = self.parent_frame
-        print('Executing',repr(cmdstr),'...', end=' ')
+        print('Executing', repr(cmdstr), '...', end=' ')
         sys.stdout.flush()
-        exec (cmdstr, frame.f_globals,frame.f_locals)
+        exec (cmdstr, frame.f_globals, frame.f_locals)
         print('ok')
         sys.stdout.flush()
         return
 
-if int(os.environ.get('NUMPY_IMPORT_DEBUG','0')):
+if int(os.environ.get('NUMPY_IMPORT_DEBUG', '0')):
     PackageLoader = PackageLoaderDebug