Apply pyupgrade

Author: aseyboldt

docs/source/conf.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 #
 # pymc3 documentation build configuration file, created by
 # sphinx-quickstart on Sat Dec 26 14:40:23 2015.

docs/source/sphinxext/gallery_generator.py

@@ -70,13 +70,13 @@ def __init__(self, filename, target_dir):
         self.basename = os.path.basename(filename)
         self.stripped_name = os.path.splitext(self.basename)[0]
         self.output_html = os.path.join(
-            "..", "notebooks", "{}.html".format(self.stripped_name)
+            "..", "notebooks", f"{self.stripped_name}.html"
         )
         self.image_dir = os.path.join(target_dir, "_images")
         self.png_path = os.path.join(
-            self.image_dir, "{}.png".format(self.stripped_name)
+            self.image_dir, f"{self.stripped_name}.png"
         )
-        with open(filename, "r") as fid:
+        with open(filename) as fid:
             self.json_source = json.load(fid)
         self.pagetitle = self.extract_title()
         self.default_image_loc = DEFAULT_IMG_LOC
@@ -89,7 +89,7 @@ def __init__(self, filename, target_dir):
 
             self.gen_previews()
         else:
-            print("skipping {0}".format(filename))
+            print(f"skipping {filename}")
 
     def extract_preview_pic(self):
         """By default, just uses the last image in the notebook."""
@@ -136,7 +136,7 @@ def build_gallery(srcdir, gallery):
     working_dir = os.getcwd()
     os.chdir(srcdir)
     static_dir = os.path.join(srcdir, "_static")
-    target_dir = os.path.join(srcdir, "nb_{}".format(gallery))
+    target_dir = os.path.join(srcdir, f"nb_{gallery}")
     image_dir = os.path.join(target_dir, "_images")
     source_dir = os.path.abspath(
         os.path.join(os.path.dirname(os.path.dirname(srcdir)), "notebooks")
@@ -182,8 +182,8 @@ def build_gallery(srcdir, gallery):
                 "thumb": os.path.basename(default_png_path),
             }
 
-    js_file = os.path.join(image_dir, "gallery_{}_contents.js".format(gallery))
-    with open(table_of_contents_file, "r") as toc:
+    js_file = os.path.join(image_dir, f"gallery_{gallery}_contents.js")
+    with open(table_of_contents_file) as toc:
         table_of_contents = toc.read()
 
     js_contents = "Gallery.examples = {}\n{}".format(

pymc3/backends/base.py

@@ -347,8 +347,8 @@ def __getitem__(self, idx):
             return self.get_sampler_stats(var, burn=burn, thin=thin)
         raise KeyError("Unknown variable %s" % var)
 
-    _attrs = set(['_straces', 'varnames', 'chains', 'stat_names',
-                  'supports_sampler_stats', '_report'])
+    _attrs = {'_straces', 'varnames', 'chains', 'stat_names',
+                  'supports_sampler_stats', '_report'}
 
     def __getattr__(self, name):
         # Avoid infinite recursion when called before __init__
@@ -417,7 +417,7 @@ def add_values(self, vals, overwrite=False) -> None:
                     self.varnames.remove(k)
                     new_var = 0
                 else:
-                    raise ValueError("Variable name {} already exists.".format(k))
+                    raise ValueError(f"Variable name {k} already exists.")
 
             self.varnames.append(k)
 
@@ -448,7 +448,7 @@ def remove_values(self, name):
         """
         varnames = self.varnames
         if name not in varnames:
-            raise KeyError("Unknown variable {}".format(name))
+            raise KeyError(f"Unknown variable {name}")
         self.varnames.remove(name)
         chains = self._straces
         for chain in chains.values():

pymc3/backends/hdf5.py

@@ -140,7 +140,7 @@ def sampler_vars(self, values):
                             data.create_dataset(varname, (self.draws,), dtype=dtype, maxshape=(None,))
                 elif data.keys() != sampler.keys():
                     raise ValueError(
-                        "Sampler vars can't change, names incompatible: {} != {}".format(data.keys(), sampler.keys()))
+                        f"Sampler vars can't change, names incompatible: {data.keys()} != {sampler.keys()}")
             self.records_stats = True
 
     def setup(self, draws, chain, sampler_vars=None):

pymc3/backends/ndarray.py

@@ -176,7 +176,7 @@ def load(self, model: Model) -> 'NDArray':
             raise TraceDirectoryError("%s is not a trace directory" % self.directory)
 
         new_trace = NDArray(model=model)
-        with open(self.metadata_path, 'r') as buff:
+        with open(self.metadata_path) as buff:
             metadata = json.load(buff)
 
         metadata['_stats'] = [{k: np.array(v) for k, v in stat.items()} for stat in metadata['_stats']]

pymc3/backends/sqlite.py

@@ -340,8 +340,8 @@ def load(name, model=None):
     db.connect()
     varnames = _get_table_list(db.cursor)
     if len(varnames) == 0:
-        raise ValueError(('Can not get variable list for database'
-                          '`{}`'.format(name)))
+        raise ValueError('Can not get variable list for database'
+                          '`{}`'.format(name))
     chains = _get_chain_list(db.cursor, varnames[0])
 
     straces = []
@@ -367,14 +367,14 @@ def _get_table_list(cursor):
 
 
 def _get_var_strs(cursor, varname):
-    cursor.execute('SELECT * FROM [{}]'.format(varname))
+    cursor.execute(f'SELECT * FROM [{varname}]')
     col_names = (col_descr[0] for col_descr in cursor.description)
     return [name for name in col_names if name.startswith('v')]
 
 
 def _get_chain_list(cursor, varname):
     """Return a list of sorted chains for `varname`."""
-    cursor.execute('SELECT DISTINCT chain FROM [{}]'.format(varname))
+    cursor.execute(f'SELECT DISTINCT chain FROM [{varname}]')
     chains = sorted([chain[0] for chain in cursor.fetchall()])
     return chains
 

pymc3/backends/text.py

@@ -91,7 +91,7 @@ def setup(self, draws, chain):
             self._fh.close()
 
         self.chain = chain
-        self.filename = os.path.join(self.name, 'chain-{}.csv'.format(chain))
+        self.filename = os.path.join(self.name, f'chain-{chain}.csv')
 
         cnames = [fv for v in self.varnames for fv in self.flat_names[v]]
 
@@ -201,7 +201,7 @@ def load(name, model=None):
     files = glob(os.path.join(name, 'chain-*.csv'))
 
     if len(files) == 0:
-        raise ValueError('No files present in directory {}'.format(name))
+        raise ValueError(f'No files present in directory {name}')
 
     straces = []
     for f in files:
@@ -249,7 +249,7 @@ def dump(name, trace, chains=None):
         chains = trace.chains
 
     for chain in chains:
-        filename = os.path.join(name, 'chain-{}.csv'.format(chain))
+        filename = os.path.join(name, f'chain-{chain}.csv')
         df = ttab.trace_to_dataframe(
             trace, chains=chain, include_transformed=True)
         df.to_csv(filename, index=False)

pymc3/distributions/continuous.py

@@ -134,7 +134,7 @@ def assert_negative_support(var, label, distname, value=-1e-6):
             support = False
 
     if np.any(support):
-        msg = "The variable specified for {0} has negative support for {1}, ".format(
+        msg = "The variable specified for {} has negative support for {}, ".format(
             label, distname
         )
         msg += "likely making it unsuitable for this parameter."
@@ -294,7 +294,7 @@ def logcdf(self, value):
             tt.switch(
                 tt.eq(value, self.upper),
                 0,
-                tt.log((value - self.lower)) - tt.log((self.upper - self.lower)),
+                tt.log(value - self.lower) - tt.log(self.upper - self.lower),
             ),
         )
 
@@ -1887,7 +1887,7 @@ class StudentT(Continuous):
 
     def __init__(self, nu, mu=0, lam=None, sigma=None, sd=None, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        super(StudentT, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         if sd is not None:
             sigma = sd
             warnings.warn("sd is deprecated, use sigma instead", DeprecationWarning)

pymc3/distributions/distribution.py

@@ -60,7 +60,7 @@ def __new__(cls, name, *args, **kwargs):
                             "for a standalone distribution.")
 
         if not isinstance(name, string_types):
-            raise TypeError("Name needs to be a string but got: {}".format(name))
+            raise TypeError(f"Name needs to be a string but got: {name}")
 
         data = kwargs.pop('observed', None)
         cls.data = data
@@ -728,7 +728,7 @@ def draw_values(params, point=None, size=None):
         # test_distributions_random::TestDrawValues::test_draw_order fails without it
         # The remaining params that must be drawn are all hashable
         to_eval = set()
-        missing_inputs = set([j for j, p in symbolic_params])
+        missing_inputs = {j for j, p in symbolic_params}
         while to_eval or missing_inputs:
             if to_eval == missing_inputs:
                 raise ValueError('Cannot resolve inputs for {}'.format([get_var_name(params[j]) for j in to_eval]))
@@ -828,7 +828,7 @@ def vectorize_theano_function(f, inputs, output):
     """
     inputs_signatures = ",".join(
         [
-            get_vectorize_signature(var, var_name="i_{}".format(input_ind))
+            get_vectorize_signature(var, var_name=f"i_{input_ind}")
             for input_ind, var in enumerate(inputs)
         ]
     )
@@ -846,9 +846,9 @@ def get_vectorize_signature(var, var_name="i"):
         return "()"
     else:
         sig = ",".join(
-            ["{}_{}".format(var_name, axis_ind) for axis_ind in range(var.ndim)]
+            [f"{var_name}_{axis_ind}" for axis_ind in range(var.ndim)]
         )
-        return "({})".format(sig)
+        return f"({sig})"
 
 
 def _draw_value(param, point=None, givens=None, size=None):

pymc3/distributions/mixture.py

@@ -118,7 +118,7 @@ def __init__(self, w, comp_dists, *args, **kwargs):
             isinstance(comp_dists, Distribution)
             or (
                 isinstance(comp_dists, Iterable)
-                and all((isinstance(c, Distribution) for c in comp_dists))
+                and all(isinstance(c, Distribution) for c in comp_dists)
             )
         ):
             raise TypeError(

pymc3/distributions/posterior_predictive.py

@@ -88,7 +88,7 @@ def __init__(
             assert point_list is None and dict is None
             self.data = {}  # Dict[str, np.ndarray]
             self._len = sum(
-                (len(multi_trace._straces[chain]) for chain in multi_trace.chains)
+                len(multi_trace._straces[chain]) for chain in multi_trace.chains
             )
             self.varnames = multi_trace.varnames
             for vn in multi_trace.varnames:
@@ -153,15 +153,15 @@ def __getitem__(self, item: Union[slice, int]) -> "_TraceDict":
 
     def __getitem__(self, item):
         if isinstance(item, str):
-            return super(_TraceDict, self).__getitem__(item)
+            return super().__getitem__(item)
         elif isinstance(item, slice):
             return self._extract_slice(item)
         elif isinstance(item, int):
             return _TraceDict(
                 dict={k: np.atleast_1d(v[item]) for k, v in self.data.items()}
             )
         elif hasattr(item, "name"):
-            return super(_TraceDict, self).__getitem__(item.name)
+            return super().__getitem__(item.name)
         else:
             raise IndexError("Illegal index %s for _TraceDict" % str(item))
 
@@ -242,7 +242,7 @@ def fast_sample_posterior_predictive(
                 "Should not specify both keep_size and samples arguments"
             )
 
-        if isinstance(trace, list) and all((isinstance(x, dict) for x in trace)):
+        if isinstance(trace, list) and all(isinstance(x, dict) for x in trace):
             _trace = _TraceDict(point_list=trace)
         elif isinstance(trace, MultiTrace):
             _trace = _TraceDict(multi_trace=trace)
@@ -454,7 +454,7 @@ def draw_values(self) -> List[np.ndarray]:
             # test_distributions_random::TestDrawValues::test_draw_order fails without it
             # The remaining params that must be drawn are all hashable
             to_eval: Set[int] = set()
-            missing_inputs: Set[int] = set([j for j, p in self.symbolic_params])
+            missing_inputs: Set[int] = {j for j, p in self.symbolic_params}
 
             while to_eval or missing_inputs:
                 if to_eval == missing_inputs:

pymc3/distributions/shape_utils.py

@@ -58,14 +58,14 @@ def _check_shape_type(shape):
         shape = np.atleast_1d(shape)
         for s in shape:
             if isinstance(s, np.ndarray) and s.ndim > 0:
-                raise TypeError("Value {} is not a valid integer".format(s))
+                raise TypeError(f"Value {s} is not a valid integer")
             o = int(s)
             if o != s:
-                raise TypeError("Value {} is not a valid integer".format(s))
+                raise TypeError(f"Value {s} is not a valid integer")
             out.append(o)
     except Exception:
         raise TypeError(
-            "Supplied value {} does not represent a valid shape".format(shape)
+            f"Supplied value {shape} does not represent a valid shape"
         )
     return tuple(out)
 
@@ -103,7 +103,7 @@ def shapes_broadcasting(*args, raise_exception=False):
             if raise_exception:
                 raise ValueError(
                     "Supplied shapes {} do not broadcast together".format(
-                        ", ".join(["{}".format(a) for a in args])
+                        ", ".join([f"{a}" for a in args])
                     )
                 )
             else:
@@ -165,7 +165,7 @@ def broadcast_dist_samples_shape(shapes, size=None):
         if broadcasted_shape is None:
             raise ValueError(
                 "Cannot broadcast provided shapes {} given size: {}".format(
-                    ", ".join(["{}".format(s) for s in shapes]), size
+                    ", ".join([f"{s}" for s in shapes]), size
                 )
             )
         return broadcasted_shape
@@ -181,7 +181,7 @@ def broadcast_dist_samples_shape(shapes, size=None):
     except ValueError:
         raise ValueError(
             "Cannot broadcast provided shapes {} given size: {}".format(
-                ", ".join(["{}".format(s) for s in shapes]), size
+                ", ".join([f"{s}" for s in shapes]), size
             )
         )
     broadcastable_shapes = []

pymc3/distributions/simulator.py

@@ -43,9 +43,9 @@ def __init__(
             Distance functions. Available options are "gaussian_kernel" (default), "wasserstein",
             "energy" or a user defined function that takes epsilon (a scalar), and the summary
             statistics of observed_data, and simulated_data as input.
-            ``gaussian_kernel`` :math: `\sum \left(-0.5  \left(\frac{xo - xs}{\epsilon}\right)^2\right)`
-            ``wasserstein`` :math: `\frac{1}{n} \sum{\left(\frac{|xo - xs|}{\epsilon}\right)}`
-            ``energy`` :math: `\sqrt{2} \sqrt{\frac{1}{n} \sum \left(\frac{|xo - xs|}{\epsilon}\right)^2}`
+            ``gaussian_kernel`` :math: `\\sum \\left(-0.5  \\left(\frac{xo - xs}{\\epsilon}\right)^2\right)`
+            ``wasserstein`` :math: `\frac{1}{n} \\sum{\\left(\frac{|xo - xs|}{\\epsilon}\right)}`
+            ``energy`` :math: `\\sqrt{2} \\sqrt{\frac{1}{n} \\sum \\left(\frac{|xo - xs|}{\\epsilon}\right)^2}`
             For the wasserstein and energy distances the observed data xo and simulated data xs
             are internally sorted (i.e. the sum_stat is "sort").
         sum_stat: str or callable
@@ -125,7 +125,7 @@ def _str_repr(self, name=None, dist=None, formatting="plain"):
         distance = self.distance.__name__
 
         if formatting == "latex":
-            return f"$\\text{{{name}}} \sim  \\text{{Simulator}}(\\text{{{function}}}({params}), \\text{{{distance}}}, \\text{{{sum_stat}}})$"
+            return f"$\\text{{{name}}} \\sim  \\text{{Simulator}}(\\text{{{function}}}({params}), \\text{{{distance}}}, \\text{{{sum_stat}}})$"
         else:
             return f"{name} ~ Simulator({function}({params}), {distance}, {sum_stat})"
 

pymc3/examples/samplers_mvnormal.py

@@ -53,7 +53,7 @@ def run(steppers, p):
             print('{} samples across {} chains'.format(len(mt) * mt.nchains, mt.nchains))
             traces[name] = mt
             en = pm.ess(mt)
-            print('effective: {}\r\n'.format(en))
+            print(f'effective: {en}\r\n')
             if USE_XY:
                 effn[name] = np.mean(en['x']) / len(mt) / mt.nchains
             else:

pymc3/exceptions.py

@@ -45,11 +45,11 @@ class ShapeError(Exception):
     """Error that the shape of a variable is incorrect."""
     def __init__(self, message, actual=None, expected=None):
         if actual is not None and expected is not None:
-            super().__init__('{} (actual {} != expected {})'.format(message, actual, expected))
+            super().__init__(f'{message} (actual {actual} != expected {expected})')
         elif actual is not None and expected is None:
-            super().__init__('{} (actual {})'.format(message, actual))
+            super().__init__(f'{message} (actual {actual})')
         elif actual is None and expected is not None:
-            super().__init__('{} (expected {})'.format(message, expected))
+            super().__init__(f'{message} (expected {expected})')
         else:
             super().__init__(message)
 
@@ -58,10 +58,10 @@ class DtypeError(TypeError):
     """Error that the dtype of a variable is incorrect."""
     def __init__(self, message, actual=None, expected=None):
         if actual is not None and expected is not None:
-            super().__init__('{} (actual {} != expected {})'.format(message, actual, expected))
+            super().__init__(f'{message} (actual {actual} != expected {expected})')
         elif actual is not None and expected is None:
-            super().__init__('{} (actual {})'.format(message, actual))
+            super().__init__(f'{message} (actual {actual})')
         elif actual is None and expected is not None:
-            super().__init__('{} (expected {})'.format(message, expected))
+            super().__init__(f'{message} (expected {expected})')
         else:
             super().__init__(message)