rtc-tools 2.5.2rc4__py3-none-any.whl → 2.6.0__py3-none-any.whl

rtctools/optimization/single_pass_goal_programming_mixin.py

@@ -5,12 +5,16 @@ from enum import Enum
 from typing import Dict, Union
 
 import casadi as ca
-
 import numpy as np
 
 from .goal_programming_mixin import GoalProgrammingMixin
-from .goal_programming_mixin_base import Goal, StateGoal, _GoalProgrammingMixinBase  # noqa: F401
-from .goal_programming_mixin_base import _EmptyEnsembleList, _EmptyEnsembleOrderedDict
+from .goal_programming_mixin_base import (  # noqa: F401
+    Goal,
+    StateGoal,
+    _EmptyEnsembleList,
+    _EmptyEnsembleOrderedDict,
+    _GoalProgrammingMixinBase,
+)
 from .timeseries import Timeseries
 
 logger = logging.getLogger("rtctools")
@@ -92,7 +96,10 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
         self.__path_objectives_per_priority = []
 
         if isinstance(self, GoalProgrammingMixin):
-            raise Exception("Cannot be an instance of both GoalProgrammingMixin and SinglePassGoalProgrammingMixin")
+            raise Exception(
+                "Cannot be an instance of both GoalProgrammingMixin "
+                "and SinglePassGoalProgrammingMixin"
+            )
 
     @property
     def extra_variables(self):
@@ -104,7 +111,7 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
     def bounds(self):
         bounds = super().bounds()
-        for epsilon in (self.__problem_epsilons + self.__problem_path_epsilons):
+        for epsilon in self.__problem_epsilons + self.__problem_path_epsilons:
             bounds[epsilon.name()] = (0.0, 1.0)
         return bounds
 
@@ -115,7 +122,7 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
         # Append min/max timeseries to the constant inputs. Note that min/max
         # timeseries are shared between all ensemble members.
-        for (variable, value) in self.__problem_path_timeseries:
+        for variable, value in self.__problem_path_timeseries:
             if isinstance(value, np.ndarray):
                 value = Timeseries(self.times(), np.broadcast_to(value, (n_times, len(value))))
             elif not isinstance(value, Timeseries):
@@ -129,7 +136,7 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
         # Append min/max values to the parameters. Note that min/max values
         # are shared between all ensemble members.
-        for (variable, value) in self.__problem_parameters:
+        for variable, value in self.__problem_parameters:
             parameters[variable] = value
 
         return parameters
@@ -143,7 +150,8 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
         additional_constraints = itertools.chain(
             self.__constraint_store[ensemble_member].values(),
-            self.__problem_constraints[ensemble_member])
+            self.__problem_constraints[ensemble_member],
+        )
 
         for constraint in additional_constraints:
             constraints.append((constraint.function(self), constraint.min, constraint.max))
@@ -155,7 +163,8 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
         additional_path_constraints = itertools.chain(
             self.__path_constraint_store[ensemble_member].values(),
-            self.__problem_path_constraints[ensemble_member])
+            self.__problem_path_constraints[ensemble_member],
+        )
 
         for constraint in additional_path_constraints:
             path_constraints.append((constraint.function(self), constraint.min, constraint.max))
@@ -163,32 +172,30 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
         return path_constraints
 
     def solver_options(self):
-
         # TODO: Split off into private
 
         # Call parent
         options = super().solver_options()
 
-        solver = options['solver']
-        assert solver in ['bonmin', 'ipopt']
+        solver = options["solver"]
+        assert solver in ["bonmin", "ipopt"]
 
         # Make sure constant states, such as min/max timeseries for violation variables,
         # are turned into parameters for the final optimization problem.
         ipopt_options = options[solver]
-        ipopt_options['fixed_variable_treatment'] = 'make_parameter'
+        ipopt_options["fixed_variable_treatment"] = "make_parameter"
 
         # Define temporary variable to avoid infinite loop between
         # solver_options and goal_programming_options.
         self._loop_breaker_solver_options = True
 
-        if not hasattr(self, '_loop_breaker_goal_programming_options'):
-            if not self.goal_programming_options()['mu_reinit']:
-                ipopt_options['mu_strategy'] = 'monotone'
+        if not hasattr(self, "_loop_breaker_goal_programming_options"):
+            if not self.goal_programming_options()["mu_reinit"]:
+                ipopt_options["mu_strategy"] = "monotone"
                 if not self._gp_first_run:
-                    ipopt_options['mu_init'] = self.solver_stats['iterations'][
-                        'mu'][-1]
+                    ipopt_options["mu_init"] = self.solver_stats["iterations"]["mu"][-1]
 
-        delattr(self, '_loop_breaker_solver_options')
+        delattr(self, "_loop_breaker_solver_options")
 
         return options
 
@@ -224,51 +231,53 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
         If ``fix_minimized_values`` is set to ``True``, goal functions will be set to equal their
         optimized values in optimization problems generated during subsequent priorities. Otherwise,
         only an upper bound will be set. Use of this option is normally not required.
-        Note that the use of this option may add non-convex constraints to the optimization problem.
-        The default value for this parameter is ``True`` for the default solvers IPOPT/BONMIN. If any
-        other solver is used, the default value is ``False``.
+        Note that the use of this option may add non-convex constraints to the optimization
+        problem. The default value for this parameter is ``True`` for the default solvers
+        IPOPT/BONMIN. If any other solver is used, the default value is ``False``.
 
-        If ``check_monotonicity`` is set to ``True``, then it will be checked whether goals with the same
-        function key form a monotonically decreasing sequence with regards to the target interval.
+        If ``check_monotonicity`` is set to ``True``, then it will be checked whether goals with
+        the same function key form a monotonically decreasing sequence with regards to the target
+        interval.
 
-        The option ``equality_threshold`` controls when a two-sided inequality constraint is folded into
-        an equality constraint.
+        The option ``equality_threshold`` controls when a two-sided inequality constraint is folded
+        into an equality constraint.
 
-        If ``scale_by_problem_size`` is set to ``True``, the objective (i.e. the sum of the violation variables)
-        will be divided by the number of goals, and the path objective will be divided by the number
-        of path goals and the number of active time steps (per goal). This will make sure the objectives are always in
-        the range [0, 1], at the cost of solving each goal/time step less accurately.
+        If ``scale_by_problem_size`` is set to ``True``, the objective (i.e. the sum of the
+        violation variables) will be divided by the number of goals, and the path objective will
+        be divided by the number of path goals and the number of active time steps (per goal).
+        This will make sure the objectives are always in the range [0, 1], at the cost of solving
+        each goal/time step less accurately.
 
         :returns: A dictionary of goal programming options.
         """
 
         options = {}
 
-        options['mu_reinit'] = True
-        options['constraint_relaxation'] = 0.0  # Disable by default
-        options['fix_minimized_values'] = False
-        options['check_monotonicity'] = True
-        options['equality_threshold'] = 1e-8
-        options['scale_by_problem_size'] = False
+        options["mu_reinit"] = True
+        options["constraint_relaxation"] = 0.0  # Disable by default
+        options["fix_minimized_values"] = False
+        options["check_monotonicity"] = True
+        options["equality_threshold"] = 1e-8
+        options["scale_by_problem_size"] = False
 
         # Forced options to be able to re-use GoalProgrammingMixin's
         # GoalProgrammingMixin._gp_* functions. These are not relevant for
         # SinglePassGoalProgrammingMixin, or should be set to a certain value
         # for it to make sense.
-        options['violation_relaxation'] = 0.0  # Disable by default
-        options['violation_tolerance'] = np.inf  # Disable by default
-        options['interior_distance'] = 1e-6
-        options['keep_soft_constraints'] = True
+        options["violation_relaxation"] = 0.0  # Disable by default
+        options["violation_tolerance"] = np.inf  # Disable by default
+        options["interior_distance"] = 1e-6
+        options["keep_soft_constraints"] = True
 
         # Define temporary variable to avoid infinite loop between
         # solver_options and goal_programming_options.
         self._loop_breaker_goal_programming_options = True
 
-        if not hasattr(self, '_loop_breaker_solver_options'):
-            if self.solver_options()['solver'] in {'ipopt', 'bonmin'}:
-                options['fix_minimized_values'] = True
+        if not hasattr(self, "_loop_breaker_solver_options"):
+            if self.solver_options()["solver"] in {"ipopt", "bonmin"}:
+                options["fix_minimized_values"] = True
 
-        delattr(self, '_loop_breaker_goal_programming_options')
+        delattr(self, "_loop_breaker_goal_programming_options")
 
         return options
 
@@ -288,13 +297,26 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
         self._gp_validate_goals(goals, is_path_goal=False)
         self._gp_validate_goals(path_goals, is_path_goal=True)
 
-        priorities = sorted({int(goal.priority) for goal in itertools.chain(goals, path_goals) if not goal.is_empty})
+        priorities = sorted(
+            {int(goal.priority) for goal in itertools.chain(goals, path_goals) if not goal.is_empty}
+        )
 
         for priority in priorities:
-            subproblems.append((
-                priority,
-                [goal for goal in goals if int(goal.priority) == priority and not goal.is_empty],
-                [goal for goal in path_goals if int(goal.priority) == priority and not goal.is_empty]))
+            subproblems.append(
+                (
+                    priority,
+                    [
+                        goal
+                        for goal in goals
+                        if int(goal.priority) == priority and not goal.is_empty
+                    ],
+                    [
+                        goal
+                        for goal in path_goals
+                        if int(goal.priority) == priority and not goal.is_empty
+                    ],
+                )
+            )
 
         # Solve the subproblems one by one
         logger.info("Starting goal programming")
@@ -302,7 +324,9 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
         success = False
 
         self.__constraint_store = [OrderedDict() for ensemble_member in range(self.ensemble_size)]
-        self.__path_constraint_store = [OrderedDict() for ensemble_member in range(self.ensemble_size)]
+        self.__path_constraint_store = [
+            OrderedDict() for ensemble_member in range(self.ensemble_size)
+        ]
 
         self.__problem_constraints = [[] for ensemble_member in range(self.ensemble_size)]
         self.__problem_path_constraints = [[] for ensemble_member in range(self.ensemble_size)]
@@ -325,15 +349,21 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
         self.__objectives = []
 
         for i, (_, goals, path_goals) in enumerate(subproblems):
-            (subproblem_epsilons, subproblem_objectives,
-             subproblem_soft_constraints, hard_constraints,
-             subproblem_parameters) = \
-                self._gp_goal_constraints(goals, i, options, is_path_goal=False)
-
-            (subproblem_path_epsilons, subproblem_path_objectives,
-             subproblem_path_soft_constraints, path_hard_constraints,
-             subproblem_path_timeseries) = \
-                self._gp_goal_constraints(path_goals, i, options, is_path_goal=True)
+            (
+                subproblem_epsilons,
+                subproblem_objectives,
+                subproblem_soft_constraints,
+                hard_constraints,
+                subproblem_parameters,
+            ) = self._gp_goal_constraints(goals, i, options, is_path_goal=False)
+
+            (
+                subproblem_path_epsilons,
+                subproblem_path_objectives,
+                subproblem_path_soft_constraints,
+                path_hard_constraints,
+                subproblem_path_timeseries,
+            ) = self._gp_goal_constraints(path_goals, i, options, is_path_goal=True)
 
             # Put hard constraints in the constraint stores
             self._gp_update_constraint_store(self.__constraint_store, hard_constraints)
@@ -349,9 +379,11 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
             for ensemble_member in range(self.ensemble_size):
                 self.__problem_constraints[ensemble_member].extend(
-                    subproblem_soft_constraints[ensemble_member])
+                    subproblem_soft_constraints[ensemble_member]
+                )
                 self.__problem_path_constraints[ensemble_member].extend(
-                    subproblem_path_soft_constraints[ensemble_member])
+                    subproblem_path_soft_constraints[ensemble_member]
+                )
 
             self.__objectives_per_priority.append(subproblem_objectives)
             self.__path_objectives_per_priority.append(subproblem_path_objectives)
@@ -364,7 +396,10 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
             # Solve subproblem
             success = super().optimize(
-                preprocessing=False, postprocessing=False, log_solver_failure_as_error=log_solver_failure_as_error)
+                preprocessing=False,
+                postprocessing=False,
+                log_solver_failure_as_error=log_solver_failure_as_error,
+            )
             if not success:
                 break
 
@@ -376,15 +411,18 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
             # two relevant options here for later use.
             options = self.goal_programming_options()
             self.__objective_constraint_options = {
-                k: v for k, v in options.items()
-                if k in {'fix_minimized_values', 'constraint_relaxation'}
+                k: v
+                for k, v in options.items()
+                if k in {"fix_minimized_values", "constraint_relaxation"}
             }
 
             # Store results.  Do this here, to make sure we have results even
             # if a subsequent priority fails.
             self.__results_are_current = False
-            self.__results = [self.extract_results(
-                ensemble_member) for ensemble_member in range(self.ensemble_size)]
+            self.__results = [
+                self.extract_results(ensemble_member)
+                for ensemble_member in range(self.ensemble_size)
+            ]
             self.__results_are_current = True
 
             # Call the post priority hook, so that intermediate results can be
@@ -403,16 +441,21 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
         return success
 
     def transcribe(self):
-
         def _objective_func(subproblem_objectives, subproblem_path_objectives):
             val = 0.0
             for ensemble_member in range(self.ensemble_size):
                 n_objectives = self._gp_n_objectives(
-                    subproblem_objectives, subproblem_path_objectives, ensemble_member)
+                    subproblem_objectives, subproblem_path_objectives, ensemble_member
+                )
                 expr = self._gp_objective(subproblem_objectives, n_objectives, ensemble_member)
-                expr += ca.sum1(self.map_path_expression(
-                    self._gp_path_objective(subproblem_path_objectives, n_objectives, ensemble_member),
-                    ensemble_member))
+                expr += ca.sum1(
+                    self.map_path_expression(
+                        self._gp_path_objective(
+                            subproblem_path_objectives, n_objectives, ensemble_member
+                        ),
+                        ensemble_member,
+                    )
+                )
                 val += self.ensemble_member_probability(ensemble_member) * expr
 
             return val
@@ -426,8 +469,11 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
             # Objectives
             for subproblem_objectives, subproblem_path_objectives in zip(
-                    self.__objectives_per_priority, self.__path_objectives_per_priority):
-                self.__objectives.append(_objective_func(subproblem_objectives, subproblem_path_objectives))
+                self.__objectives_per_priority, self.__path_objectives_per_priority
+            ):
+                self.__objectives.append(
+                    _objective_func(subproblem_objectives, subproblem_path_objectives)
+                )
 
             if self.single_pass_method == SinglePassMethod.UPDATE_OBJECTIVE_CONSTRAINT_BOUNDS:
                 # The objectives are also directly added as constraints
@@ -439,18 +485,20 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
             options = self.__objective_constraint_options
 
             previous_objective = self.__objectives[self.__current_priority - 1]
-            f = ca.Function('tmp', [self.solver_input], [previous_objective])
+            f = ca.Function("tmp", [self.solver_input], [previous_objective])
             obj_val = float(f(self.solver_output))
 
-            if options['fix_minimized_values']:
+            if options["fix_minimized_values"]:
                 lb, ub = obj_val, obj_val
                 self.linear_collocation = False  # Disable solver option jac_c_constant for IPOPT
             else:
-                obj_val += options['constraint_relaxation']
+                obj_val += options["constraint_relaxation"]
                 lb, ub = -np.inf, obj_val
 
             if self.single_pass_method == SinglePassMethod.APPEND_CONSTRAINTS_OBJECTIVE:
-                self.__additional_constraints.append((self.__objectives[self.__current_priority - 1], lb, ub))
+                self.__additional_constraints.append(
+                    (self.__objectives[self.__current_priority - 1], lb, ub)
+                )
             elif self.single_pass_method == SinglePassMethod.UPDATE_OBJECTIVE_CONSTRAINT_BOUNDS:
                 ind = self.__current_priority - 1
                 constraint = self.__additional_constraints[ind]
@@ -463,13 +511,13 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
         if self.__additional_constraints:
             g_extra, lbg_extra, ubg_extra = zip(*self.__additional_constraints)
 
-            g = ca.vertcat(nlp['g'], *g_extra)
+            g = ca.vertcat(nlp["g"], *g_extra)
             lbg = [*lbg.copy(), *lbg_extra]
             ubg = [*ubg.copy(), *ubg_extra]
 
-            nlp['g'] = g
+            nlp["g"] = g
 
-        nlp['f'] = self.__objectives[self.__current_priority]
+        nlp["f"] = self.__objectives[self.__current_priority]
 
         if not self._gp_first_run:
             x0 = self.solver_output.copy()
@@ -508,24 +556,25 @@ class CachingQPSol:
         self._tlcache = {}
 
     def __call__(self, name, solver_name, nlp, options):
-
         class Solver:
-            def __init__(self, nlp=nlp, solver_name=solver_name, options=options, cache=self._tlcache):
-                x = nlp['x']
-                f = nlp['f']
-                g = nlp['g']
+            def __init__(
+                self, nlp=nlp, solver_name=solver_name, options=options, cache=self._tlcache
+            ):
+                x = nlp["x"]
+                f = nlp["f"]
+                g = nlp["g"]
 
                 if isinstance(x, ca.MX):
                     # Can only convert SX to DM
-                    x = ca.SX.sym('X', *x.shape)
-                    x_mx = nlp['x']
+                    x = ca.SX.sym("X", *x.shape)
+                    x_mx = nlp["x"]
                     expand = True
                 else:
                     x_mx = None
                     expand = False
 
                 if expand:
-                    expand_f = ca.Function('f', [x_mx], [f]).expand()
+                    expand_f = ca.Function("f", [x_mx], [f]).expand()
                     f = expand_f(x)
 
                 # Gradient of the objective: gf == Hx + g
@@ -535,37 +584,40 @@ class CachingQPSol:
                 c = ca.substitute(gf, x, ca.DM.zeros(x.sparsity()))
 
                 # Identify the quadratic term in the objective
-                H = 0.5*ca.jacobian(gf, x, {"symmetric": True})
+                H = 0.5 * ca.jacobian(gf, x, {"symmetric": True})
 
                 if cache:
-                    if not x.size1() == cache['A'].size2():
+                    if not x.size1() == cache["A"].size2():
                         raise Exception(
-                            "Number of variables {} does not match cached constraint matrix dimensions {}".format(
-                                x.size1(), cache['A'].shape))
+                            "Number of variables {} does not match "
+                            "cached constraint matrix dimensions {}".format(
+                                x.size1(), cache["A"].shape
+                            )
+                        )
 
-                    n_g_cache = cache['A'].size1()
+                    n_g_cache = cache["A"].size1()
                     n_g = g.size1()
 
                     if n_g_cache == n_g:
-                        b = cache['b']
-                        A = cache['A']
+                        b = cache["b"]
+                        A = cache["A"]
                     else:
                         g_new = g[n_g_cache:]
 
                         if expand:
-                            expand_g_new = ca.Function('f', [x_mx], [g_new]).expand()
+                            expand_g_new = ca.Function("f", [x_mx], [g_new]).expand()
                             g_new = expand_g_new(x)
 
                         # Identify the constant term in the constraints
-                        b = ca.vertcat(cache['b'],
-                                       ca.substitute(g_new, x, ca.DM.zeros(x.sparsity())))
+                        b = ca.vertcat(
+                            cache["b"], ca.substitute(g_new, x, ca.DM.zeros(x.sparsity()))
+                        )
 
                         # Identify the linear term in the constraints
-                        A = ca.vertcat(cache['A'],
-                                       ca.jacobian(g_new, x))
+                        A = ca.vertcat(cache["A"], ca.jacobian(g_new, x))
                 else:
                     if expand:
-                        expand_g = ca.Function('f', [x_mx], [g]).expand()
+                        expand_g = ca.Function("f", [x_mx], [g]).expand()
                         g = expand_g(x)
 
                     # Identify the constant term in the constraints
@@ -574,16 +626,12 @@ class CachingQPSol:
                     # Identify the linear term in the constraints
                     A = ca.jacobian(g, x)
 
-                cache['A'] = A
-                cache['b'] = b
+                cache["A"] = A
+                cache["b"] = b
 
-                self._solver = ca.conic("mysolver",
-                                        solver_name,
-                                        {
-                                            'h': H.sparsity(),
-                                            'a': A.sparsity()
-                                        },
-                                        options)
+                self._solver = ca.conic(
+                    "mysolver", solver_name, {"h": H.sparsity(), "a": A.sparsity()}, options
+                )
                 self._solver_in = {}
                 self._solver_in["h"] = ca.DM(H)
                 self._solver_in["g"] = ca.DM(c)
@@ -591,7 +639,6 @@ class CachingQPSol:
                 self._b = ca.DM(b)
 
             def __call__(self, x0, lbx, ubx, lbg, ubg):
-
                 self._solver_in["x0"] = x0
                 self._solver_in["lbx"] = lbx
                 self._solver_in["ubx"] = ubx
@@ -600,7 +647,7 @@ class CachingQPSol:
 
                 solver_out = self._solver(**self._solver_in)
 
-                solver_out['f'] = solver_out['cost']
+                solver_out["f"] = solver_out["cost"]
 
                 return solver_out
 

rtctools/optimization/timeseries.py

@@ -1,7 +1,6 @@
 from typing import Union
 
 import casadi as ca
-
 import numpy as np
 
 
@@ -28,7 +27,7 @@ class Timeseries:
         elif isinstance(values, (np.ndarray, list)) and len(values) == 1:
             values = values[0]
 
-        if hasattr(values, '__iter__'):
+        if hasattr(values, "__iter__"):
             self.__values = np.array(values, dtype=np.float64, copy=True)
         else:
             self.__values = np.full_like(times, values, dtype=np.float64)
@@ -47,12 +46,11 @@ class Timeseries:
         """
         return self.__values
 
-    def __neg__(self) -> 'Timeseries':
+    def __neg__(self) -> "Timeseries":
         return self.__class__(self.times, -self.values)
 
     def __repr__(self) -> str:
-        return 'Timeseries({}, {})'.format(self.__times, self.__values)
+        return "Timeseries({}, {})".format(self.__times, self.__values)
 
     def __eq__(self, other: "Timeseries") -> bool:
-        return (np.array_equal(self.times, other.times) and
-                np.array_equal(self.values, other.values))
+        return np.array_equal(self.times, other.times) and np.array_equal(self.values, other.values)

rtctools/rtctoolsapp.py

@@ -6,13 +6,12 @@ from pathlib import Path
 
 import rtctools
 
-logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s')
+logging.basicConfig(format="%(asctime)s %(levelname)s %(message)s")
 logger = logging.getLogger("rtctools")
 logger.setLevel(logging.INFO)
 
 
 def copy_libraries(*args):
-
     if not args:
         args = sys.argv[1:]
 
@@ -38,25 +37,30 @@ def copy_libraries(*args):
             else:
                 if not os.path.exists(d):
                     shutil.copy2(s, d)
-                elif Path(s).name.lower() == 'package.mo':
+                elif Path(s).name.lower() == "package.mo":
                     # Pick the largest one, assuming that all plugin packages
                     # to not provide a meaningful package.mo
                     if os.stat(s).st_size > os.stat(d).st_size:
-                        logger.warning("Overwriting '{}' with '{}' as the latter is larger.".format(d, s))
+                        logger.warning(
+                            "Overwriting '{}' with '{}' as the latter is larger.".format(d, s)
+                        )
                         os.remove(d)
                         shutil.copy2(s, d)
                     else:
-                        logger.warning("Not copying '{}' to '{}' as the latter is larger.".format(s, d))
+                        logger.warning(
+                            "Not copying '{}' to '{}' as the latter is larger.".format(s, d)
+                        )
                 else:
                     raise OSError("Could not combine two folders")
 
     dst = Path(path)
 
     library_folders = []
-    for ep in pkg_resources.iter_entry_points(group='rtctools.libraries.modelica'):
+    for ep in pkg_resources.iter_entry_points(group="rtctools.libraries.modelica"):
         if ep.name == "library_folder":
             library_folders.append(
-                Path(pkg_resources.resource_filename(ep.module_name, ep.attrs[0])))
+                Path(pkg_resources.resource_filename(ep.module_name, ep.attrs[0]))
+            )
 
     tlds = {}
     for lf in library_folders:
@@ -78,7 +82,6 @@ def copy_libraries(*args):
 
 
 def download_examples(*args):
-
     if not args:
         args = sys.argv[1:]
 
@@ -96,25 +99,22 @@ def download_examples(*args):
     from urllib.error import HTTPError
     from zipfile import ZipFile
 
-    # GitLab is blocking requests unless we specify a user agent
-    user_agent = 'Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0'
-
     version = rtctools.__version__
-    rtc_full_name = 'rtc-tools-{}'.format(version)
+    rtc_full_name = "rtc-tools-{}".format(version)
     try:
-        url = 'https://gitlab.com/deltares/rtc-tools/-/archive/' \
-            '{}/{}.zip'.format(version, rtc_full_name)
+        url = "https://gitlab.com/deltares/rtc-tools/-/archive/{}/{}.zip".format(
+            version, rtc_full_name
+        )
 
         opener = urllib.request.build_opener()
-        opener.addheaders = [('User-agent', user_agent)]
         urllib.request.install_opener(opener)
         local_filename, _ = urllib.request.urlretrieve(url)
     except HTTPError:
         sys.exit("Could not found examples for RTC-Tools version {}.".format(version))
 
-    with ZipFile(local_filename, 'r') as z:
-        target = path / 'rtc-tools-examples'
-        prefix = '{}/examples/'.format(rtc_full_name)
+    with ZipFile(local_filename, "r") as z:
+        target = path / "rtc-tools-examples"
+        prefix = "{}/examples/".format(rtc_full_name)
         members = [x for x in z.namelist() if x.startswith(prefix)]
         z.extractall(members=members)
         shutil.move(prefix, target)