pyupgrade code (#270)

* pyupgrade 3.7+

* black format

* black format of docs

* update gitignore

* updated flake8 ignore

* addressed comments

* minor flake8 fixes

Author: ewu63

.flake8

@@ -3,4 +3,5 @@ extend-exclude =
     # OptView and related files need to be fixed eventually
     pyoptsparse/postprocessing/OptView.py
     pyoptsparse/postprocessing/OptView_baseclass.py
+    pyoptsparse/postprocessing/OptView_dash.py
     pyoptsparse/postprocessing/view_saved_figure.py

.gitignore

@@ -1,5 +1,6 @@
 syntax: glob
-build/*
+build
+doc/_build
 *.pyc
 *.so
 *.out
@@ -8,4 +9,6 @@ build/*
 *.gz
 *.c
 *.cpp
-env
+env
+pyoptsparse/pySNOPT/source
+pyoptsparse/pyNLPQLP/source

doc/guide.rst

@@ -22,19 +22,19 @@ The optimization class is created using the following call:
 
 .. code-block:: python
 
-  >>> optProb = Optimization('name', objFun)
+  optProb = Optimization("name", objFun)
 
 The general template of the objective function is as follows:
 
 .. code-block:: python
 
   def obj_fun(xdict):
-    funcs = {}
-    funcs['obj_name'] = function(xdict)
-    funcs['con_name'] = function(xdict)
-    fail = False # Or True if an analysis failed
+      funcs = {}
+      funcs["obj_name"] = function(xdict)
+      funcs["con_name"] = function(xdict)
+      fail = False  # Or True if an analysis failed
 
-    return funcs, fail
+      return funcs, fail
 
 where:
 
@@ -51,19 +51,19 @@ to simply call :meth:`addVar <pyoptsparse.pyOpt_optimization.Optimization.addVar
 
 .. code-block:: python
 
-   >>> optProb.addVar('var_name')
+   optProb.addVar("var_name")
 
 This will result in a scalar variable included in the ``x`` dictionary call to ``obj_fun`` which can be accessed by doing
 
 .. code-block:: python
 
-  >>> x['var_name']
+  x["var_name"]
 
 A more complex example will include lower bounds, upper bounds and a non-zero initial value:
 
 .. code-block:: python
 
-  >>> optProb.addVar('var_name',lower=-10, upper=5, value=-2)
+  optProb.addVar("var_name", lower=-10, upper=5, value=-2)
 
 The ``lower`` or ``upper`` keywords may be specified as ``None`` to signify there is no bound on the variable.
 
@@ -84,7 +84,7 @@ For example, to add 10 variables with no lower bound, and a scale factor of 0.1:
 
 .. code-block:: python
 
-  >>> optProb.addVarGroup('con_group', 10, upper=2.5, scale=0.1)
+  optProb.addVarGroup("con_group", 10, upper=2.5, scale=0.1)
 
 
 Constraints
@@ -95,22 +95,22 @@ to use the function :meth:`addCon <pyoptsparse.pyOpt_optimization.Optimization.a
 
 .. code-block:: python
 
-  >>> optProb.addCon('not_a_real_constraint')
+  optProb.addCon("not_a_real_constraint")
 
 To include bounds on the constraints, use the ``lower`` and ``upper`` keyword arguments.
 If ``lower`` and ``upper`` are the same, it will be treated as an equality constraint:
 
 .. code-block:: python
 
-  >>> optProb.addCon('inequality_constraint', upper=10)
-  >>> optProb.addCon('equality_constraint', lower=5, upper=5)
+  optProb.addCon("inequality_constraint", upper=10)
+  optProb.addCon("equality_constraint", lower=5, upper=5)
 
 Like design variables, it is often necessary to scale constraints such that all constraint values are approximately the same order of magnitude.
 This can be specified using the ``scale`` keyword:
 
 .. code-block:: python
 
-  >>> optProb.addCon('scaled_constraint', upper=10000, scale=1.0/10000)
+  optProb.addCon("scaled_constraint", upper=10000, scale=1.0 / 10000)
 
 Even if the ``scale`` keyword is given, the ``lower`` and ``upper`` bounds are given in their un-scaled form.
 Internally, pyOptSparse will use the scaling factor to produce the following constraint:
@@ -153,14 +153,14 @@ By way of example, the code that generates the  hypothetical optimization proble
 
 .. code-block:: python
 
-  optProb.addVarGroup('varA', 3)
-  optProb.addVarGroup('varB', 1)
-  optProb.addVarGroup('varC', 3)
+  optProb.addVarGroup("varA", 3)
+  optProb.addVarGroup("varB", 1)
+  optProb.addVarGroup("varC", 3)
 
-  optProb.addConGroup('conA', 2, upper=0.0, wrt=['varB', 'varC'])
-  optProb.addConGroup('conB', 2, upper=0.0, wrt=['varC', 'varA'])
-  optProb.addConGroup('conC', 4, upper=0.0)
-  optProb.addConGroup('conD', 3, upper=0.0, wrt=['varC'])
+  optProb.addConGroup("conA", 2, upper=0.0, wrt=["varB", "varC"])
+  optProb.addConGroup("conB", 2, upper=0.0, wrt=["varC", "varA"])
+  optProb.addConGroup("conC", 4, upper=0.0)
+  optProb.addConGroup("conD", 3, upper=0.0, wrt=["varC"])
 
 Note that the order of the ``wrt`` (which stands for with-respect-to) is not significant.
 Furthermore, if the ``wrt`` argument is omitted altogether, pyOptSparse assumes that the constraint is dense.
@@ -170,7 +170,7 @@ To do so, use the following call after adding all the design variables, objectiv
 
 .. code-block:: python
 
-  >>> optProb.printSparsity()
+  optProb.printSparsity()
 
 Using the ``wrt`` keyword allows the user to determine the overall sparsity structure of the constraint Jacobian.
 However, we have currently assumed that each of the blocks with an ``X`` in is a dense sub-block.
@@ -182,12 +182,12 @@ By way of example, the call instead may be as follows:
 
 .. code-block:: python
 
-  jac = sparse.lil_matrix((3,3))
-  jac[0,0] = 1.0
-  jac[1,1] = 4.0
-  jac[2,2] = 5.0
+  jac = sparse.lil_matrix((3, 3))
+  jac[0, 0] = 1.0
+  jac[1, 1] = 4.0
+  jac[2, 2] = 5.0
 
-  optProb.addConGroup('conD', 3, upper=0.0, wrt=['varC'], linear=True, jac={'varC':jac})
+  optProb.addConGroup("conD", 3, upper=0.0, wrt=["varC"], linear=True, jac={"varC": jac})
 
 We have created a linked list sparse matrix using ``scipy.sparse``.
 Any SciPy sparse matrix format can be accepted.
@@ -215,7 +215,7 @@ This is accomplished using a the call to :meth:`addObj <pyoptsparse.pyOpt_optimi
 
 .. code-block:: python
 
-  optProb.addObj('obj_name')
+  optProb.addObj("obj_name")
 
 What this does is tell pyOptSparse that the key ``obj_name`` in the function returns will be taken as the objective.
 For optimizers that can do multi-objective optimization (e.g. NSGA2), multiple objectives can be added.
@@ -264,6 +264,7 @@ The first, and most explicit approach is to directly import the optimizer class,
 .. code-block:: python
 
   from pyoptsparse import SLSQP
+
   opt = SLSQP(...)
 
 However, in order to easily switch between different optimizers without having to import each class, a convenience function called
@@ -273,6 +274,7 @@ It accepts a string argument in addition to the usual options, and instantiates
 .. code-block:: python
 
   from pyoptsparse import OPT
+
   opt = OPT("SLSQP", ...)
 
 Note that the name of the optimizer is case-insensitive, so ``slsqp`` can also be used.

doc/postprocessing.rst

@@ -150,7 +150,7 @@ To extract the stored information in Python, first initialize a History object:
 
 .. code-block:: python
 
-    >>> hist = History('path/to/opt_hist.hst', flag='r')
+    hist = History("path/to/opt_hist.hst", flag="r")
 
 From here, various information can be extracted, using the various ``get_`` methods.
 To extract iteration history, use the function ``getValues()``.

doc/quickstart.rst

@@ -33,15 +33,15 @@ Notes:
 
     .. code-block:: python
 
-        x = xdict['xvars']
+        x = xdict["xvars"]
 
     retrieves an array of length 3 which are all the variables for this optimization. 
 
 *   The line
 
     .. code-block:: python
 
-        conval = [0]*2
+        conval = [0] * 2
 
     creates a list of length 2, which stores the numerical values of the two constraints.
     The ``funcs`` dictionary return must contain keys that match the constraint names from
@@ -52,8 +52,8 @@ Notes:
 
     .. code-block:: python
 
-        funcs['obj'] = -x[0]*x[1]*x[2]
-        funcs['con'] = conval
+        funcs["obj"] = -x[0] * x[1] * x[2]
+        funcs["con"] = conval
 
 Now the optimization problem can be initialized:
 

examples/hs015VarPlot.py

@@ -20,7 +20,7 @@
 db = {}
 opts = ["ipopt", "slsqp", "snopt", "conmin", "nlpqlp", "psqp"]
 for opt in opts:
-    fileName = "{}_hs015_Hist.hst".format(opt)
+    fileName = f"{opt}_hs015_Hist.hst"
     try:
         db[opt] = History(fileName)
     except FileNotFoundError:

pyoptsparse/postprocessing/OptView.py

@@ -634,7 +634,7 @@ def onselect_arr(self, evt):
         self.arr_data = {}
         self.val_names = []
         for i, val in enumerate(values):
-            self.val_names.append(values_orig[0] + "_{0}".format(val))
+            self.val_names.append(values_orig[0] + f"_{val}")
             self.arr_data[self.val_names[i]] = []
             for ind_dat in dat:
                 self.arr_data[self.val_names[i]].append(ind_dat[val])
@@ -768,7 +768,7 @@ def save_tec(self):
                     for j in range(m):
                         indiv_data[j] = small_data[j][i]
                     full_data = np.c_[full_data, indiv_data]
-                    var_names.append(key + "_{}".format(i))
+                    var_names.append(key + f"_{i}")
 
         filename = "OptView_tec.dat"
         self._file = open(filename, "w")
@@ -778,7 +778,7 @@ def save_tec(self):
             self._file.write('"' + name + '" ')
         self._file.write("\n")
 
-        self._file.write('Zone T= "OptView_tec_data", ' + "I={}, ".format(num_iters) + "F=POINT\n")
+        self._file.write('Zone T= "OptView_tec_data", ' + f"I={num_iters}, " + "F=POINT\n")
         np.savetxt(self._file, full_data)
         self._file.close()
 
@@ -895,7 +895,7 @@ def on_move(self, event):
                 iter_count = np.round(event.xdata, 0)
                 ind = np.where(xdat == iter_count)[0][0]
 
-                label = label + "\niter: {0:d}\nvalue: {1}".format(int(iter_count), ydat[ind])
+                label = label + f"\niter: {int(iter_count):d}\nvalue: {ydat[ind]}"
 
                 # Get the width of the window so we can scale the label placement
                 size = self.f.get_size_inches() * self.f.dpi

pyoptsparse/postprocessing/OptView_baseclass.py

@@ -17,7 +17,7 @@
 from ..pyOpt_error import pyOptSparseWarning
 
 
-class OVBaseClass(object):
+class OVBaseClass:
 
     """
     Container for display parameters, properties, and objects.
@@ -235,7 +235,7 @@ def DetermineMajorIterations(self, db, OpenMDAO):
 
         else:  # this is if it's OpenMDAO
             for i, iter_type in enumerate(self.iter_type):
-                key = "{}|{}".format(self.solver_name, i + 1)  # OpenMDAO uses 1-indexing
+                key = f"{self.solver_name}|{i + 1}"  # OpenMDAO uses 1-indexing
                 if i in self.deriv_keys:
                     self.iter_type[i] = 1.0
 
@@ -256,7 +256,7 @@ def SaveDBData(self, db, data_all, data_major, OpenMDAO, data_str):
             # If this is an OpenMDAO file, the keys are of the format
             # 'rank0:SNOPT|1', etc
             if OpenMDAO:
-                key = "{}|{}".format(self.solver_name, i + 1)  # OpenMDAO uses 1-indexing
+                key = f"{self.solver_name}|{i + 1}"  # OpenMDAO uses 1-indexing
             else:  # Otherwise the keys are simply a number
                 key = "%d" % i
 
@@ -271,7 +271,7 @@ def SaveDBData(self, db, data_all, data_major, OpenMDAO, data_str):
 
                     # Format a new_key string where we append a modifier
                     # if we have multiple history files
-                    new_key = key + "{}".format(self.histIndex)
+                    new_key = key + f"{self.histIndex}"
 
                     # If this key is not in the data dictionaries, add it
                     if new_key not in data_all:
@@ -301,7 +301,7 @@ def SaveOpenMDAOData(self, db):
 
                     # We'll rename each item, so we need to get the old item
                     # name and modify it
-                    item = old_item + "{}".format(self.histIndex)
+                    item = old_item + f"{self.histIndex}"
 
                     # Here we just have an open parenthesis, and then we will
                     # add o, c, or dv. Note that we could add multiple flags

pyoptsparse/pyALPSO/alpso.py

@@ -60,7 +60,7 @@ def alpso(dimensions, constraints, neqcons, xtype, x0, xmin, xmax, swarmsize, nh
             x0 = np.array(x0)
         elif not isinstance(x0, np.ndarray):
             pyOptSparseWarning(
-                ("Initial x must be either list or numpy.array, " "all initial positions randomly generated")
+                "Initial x must be either list or numpy.array, all initial positions randomly generated"
             )
 
     #

pyoptsparse/pyALPSO/alpso_ext.py

@@ -60,7 +60,7 @@ def alpso(dimensions, constraints, neqcons, xtype, x0, xmin, xmax, swarmsize, nh
             x0 = np.array(x0)
         elif not isinstance(x0, np.ndarray):
             pyOptSparseWarning(
-                ("Initial x must be either list or numpy.array, all initial positions randomly generated")
+                "Initial x must be either list or numpy.array, all initial positions randomly generated"
             )
 
     #

pyoptsparse/pyIPOPT/setup.py

@@ -52,7 +52,7 @@ def configuration(parent_package="", top_path=None):
             FILES,
             library_dirs=[IPOPT_LIB],
             libraries=["ipopt"],
-            extra_link_args=["-Wl,-rpath,%s -L%s" % (IPOPT_LIB, IPOPT_LIB)],
+            extra_link_args=[f"-Wl,-rpath,{IPOPT_LIB} -L{IPOPT_LIB}"],
             include_dirs=[numpy_include, IPOPT_INC],
         )
     return config

pyoptsparse/pyNSGA2/setup.py

@@ -56,14 +56,14 @@ def swig_sources(self, sources, extension):
                 else:
                     typ2 = get_swig_target(source)
                     if typ != typ2:
-                        log.warn("expected %r but source %r defines %r swig target" % (typ, source, typ2))
+                        log.warn(f"expected {typ!r} but source {source!r} defines {typ2!r} swig target")
                         if typ2 == "c++":
                             log.warn("resetting swig target to c++ (some targets may have .c extension)")
                             is_cpp = True
                             target_ext = ".cpp"
                         else:
                             log.warn("assuming that %r has c++ swig target" % (source))
-                target_file = os.path.join(target_dir, "%s_wrap%s" % (name, target_ext))
+                target_file = os.path.join(target_dir, f"{name}_wrap{target_ext}")
             else:
                 log.warn("  source %s does not exist: skipping swig'ing." % (source))
                 name = ext_name
@@ -79,7 +79,7 @@ def swig_sources(self, sources, extension):
                     target_dir = os.path.dirname(base)
                     target_file = _find_swig_target(target_dir, name)
                     if not os.path.isfile(target_file):
-                        raise DistutilsSetupError("%r missing" % (target_file,))
+                        raise DistutilsSetupError(f"{target_file!r} missing")
                     log.warn("   Yes! Using %r as up-to-date target." % (target_file))
             target_dirs.append(target_dir)
             new_sources.append(target_file)
@@ -108,7 +108,7 @@ def swig_sources(self, sources, extension):
         target = swig_targets[source]
         depends = [source] + extension.depends
         if self.force or newer_group(depends, target, "newer"):
-            log.info("%s: %s" % (os.path.basename(swig) + (is_cpp and "++" or ""), source))
+            log.info("{}: {}".format(os.path.basename(swig) + (is_cpp and "++" or ""), source))
             self.spawn(swig_cmd + self.swig_opts + ["-o", target, "-outdir", py_target_dir, source])
         else:
             log.debug("  skipping '%s' swig interface (up-to-date)" % (source))

pyoptsparse/pyOpt_MPI.py

@@ -13,7 +13,7 @@
 # isort: off
 
 
-class COMM(object):
+class COMM:
     def __init__(self):
         self.rank = 0
         self.size = 1
@@ -38,7 +38,7 @@ def Barrier(self):
         return
 
 
-class myMPI(object):
+class myMPI:
     def __init__(self):
         self.COMM_WORLD = COMM()
         self.SUM = "SUM"