rtc-tools 2.7.0.dev2__py3-none-any.whl → 2.8.0a1__py3-none-any.whl

rtctools/optimization/min_abs_goal_programming_mixin.py

@@ -1,10 +1,12 @@
 import functools
 import itertools
-from typing import List
+from typing import List, Optional
 
 import casadi as ca
 import numpy as np
 
+from rtctools._internal.ensemble_bounds_decorator import ensemble_bounds_check
+
 from .goal_programming_mixin import GoalProgrammingMixin
 from .goal_programming_mixin_base import (
     Goal,
@@ -86,8 +88,12 @@ class MinAbsGoalProgrammingMixin(_GoalProgrammingMixinBase):
     def path_variables(self):
         return super().path_variables + self.__problem_path_vars
 
-    def bounds(self):
-        bounds = super().bounds()
+    @ensemble_bounds_check
+    def bounds(self, ensemble_member: Optional[int] = None):
+        bounds = (
+            super().bounds(ensemble_member) if self.ensemble_specific_bounds else super().bounds()
+        )
+
         for abs_var in self.__problem_vars + self.__problem_path_vars:
             bounds[abs_var.name()] = (0.0, np.inf)
         return bounds

rtctools/optimization/modelica_mixin.py

@@ -1,16 +1,25 @@
+import importlib.resources
 import itertools
 import logging
-from typing import Dict, Union
+import sys
+from typing import Dict, Optional, Union
+
+# Python 3.9's importlib.metadata does not support the "group" parameter to
+# entry_points yet.
+if sys.version_info < (3, 10):
+    import importlib_metadata
+else:
+    from importlib import metadata as importlib_metadata
 
 import casadi as ca
 import numpy as np
-import pkg_resources
 import pymoca
 import pymoca.backends.casadi.api
 
 from rtctools._internal.alias_tools import AliasDict
 from rtctools._internal.caching import cached
 from rtctools._internal.casadi_helpers import substitute_in_external
+from rtctools._internal.ensemble_bounds_decorator import ensemble_bounds_check
 
 from .optimization_problem import OptimizationProblem
 from .timeseries import Timeseries
@@ -174,9 +183,9 @@ class ModelicaMixin(OptimizationProblem):
         # Where imported model libraries are located.
         library_folders = self.modelica_library_folders.copy()
 
-        for ep in pkg_resources.iter_entry_points(group="rtctools.libraries.modelica"):
+        for ep in importlib_metadata.entry_points(group="rtctools.libraries.modelica"):
             if ep.name == "library_folder":
-                library_folders.append(pkg_resources.resource_filename(ep.module_name, ep.attrs[0]))
+                library_folders.append(str(importlib.resources.files(ep.module).joinpath(ep.attr)))
 
         compiler_options["library_folders"] = library_folders
 
@@ -307,12 +316,16 @@ class ModelicaMixin(OptimizationProblem):
         return self.__initial_residual
 
     @cached
-    def bounds(self):
-        # Call parent class first for default values.
-        bounds = super().bounds()
+    @ensemble_bounds_check
+    def bounds(self, ensemble_member: Optional[int] = None):
+        bounds = (
+            super().bounds(ensemble_member) if self.ensemble_specific_bounds else super().bounds()
+        )
+
+        ensemble_member = ensemble_member if self.ensemble_specific_bounds else 0
 
         # Parameter values
-        parameters = self.parameters(0)
+        parameters = self.parameters(ensemble_member)
         parameter_values = [
             parameters.get(param.name(), param) for param in self.__mx["parameters"]
         ]
@@ -326,7 +339,7 @@ class ModelicaMixin(OptimizationProblem):
             try:
                 (m, M) = bounds[sym_name]
             except KeyError:
-                if self.__python_types.get(sym_name, float) == bool:
+                if self.__python_types.get(sym_name, float) is bool:
                     (m, M) = (0, 1)
                 else:
                     (m, M) = (-np.inf, np.inf)
@@ -400,7 +413,7 @@ class ModelicaMixin(OptimizationProblem):
         return seed
 
     def variable_is_discrete(self, variable):
-        return self.__python_types.get(variable, float) != float
+        return self.__python_types.get(variable, float) is not float
 
     @property
     @cached

rtctools/optimization/optimization_problem.py

@@ -1,12 +1,13 @@
 import logging
 from abc import ABCMeta, abstractmethod, abstractproperty
-from typing import Any, Dict, Iterator, List, Tuple, Union
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
 import casadi as ca
 import numpy as np
 
 from rtctools._internal.alias_tools import AliasDict
 from rtctools._internal.debug_check_helpers import DebugLevel, debug_check
+from rtctools._internal.ensemble_bounds_decorator import ensemble_bounds_check
 from rtctools.data.storage import DataStoreAccessor
 
 from .timeseries import Timeseries
@@ -46,6 +47,9 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
     _debug_check_level = DebugLevel.MEDIUM
     _debug_check_options = {}
 
+    #: Enable ensemble-specific bounds functionality
+    ensemble_specific_bounds = False
+
     def __init__(self, **kwargs):
         # Call parent class first for default behaviour.
         super().__init__(**kwargs)
@@ -199,12 +203,12 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
                         log_level = logging.INFO
                 logger.log(
                     log_level,
-                    "Solver succeeded with status {} ({}).".format(return_status, wall_clock_time),
+                    "Solver failed with status {} ({}).".format(return_status, wall_clock_time),
                 )
             except (AttributeError, ValueError):
                 logger.log(
                     log_level,
-                    "Solver succeeded with status {} ({}).".format(return_status, wall_clock_time),
+                    "Solver failed with status {} ({}).".format(return_status, wall_clock_time),
                 )
 
         # Do any postprocessing
@@ -221,14 +225,23 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
     def __check_bounds_control_input(self) -> None:
         # Checks if at the control inputs have bounds, log warning when a control input is not
         # bounded.
-        bounds = self.bounds()
-
-        for variable in self.dae_variables["control_inputs"]:
-            variable = variable.name()
-            if variable not in bounds:
-                logger.warning(
-                    "OptimizationProblem: control input {} has no bounds.".format(variable)
-                )
+        if self.ensemble_specific_bounds:
+            bounds_list = [
+                self.bounds(ensemble_member) for ensemble_member in range(self.ensemble_size)
+            ]
+        else:
+            bounds_list = [self.bounds()]
+
+        for ensemble_member, bounds in enumerate(bounds_list):
+            for variable in self.dae_variables["control_inputs"]:
+                variable = variable.name()
+                if variable not in bounds:
+                    logger.warning(
+                        "OptimizationProblem: control input {} has no bounds{}.".format(
+                            variable,
+                            f" ({ensemble_member=})" if self.ensemble_specific_bounds else "",
+                        )
+                    )
 
     @abstractmethod
     def transcribe(
@@ -314,6 +327,24 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         if log_level == logging.ERROR and not log_solver_failure_as_error:
             log_level = logging.INFO
 
+        if self.solver_options()["solver"].lower() == "knitro":
+            list_feas_flags = [
+                "KN_RC_OPTIMAL_OR_SATISFACTORY",
+                "KN_RC_ITER_LIMIT_FEAS",
+                "KN_RC_NEAR_OPT",
+                "KN_RC_FEAS_XTOL",
+                "KN_RC_FEAS_NO_IMPROVE",
+                "KN_RC_FEAS_FTOL",
+                "KN_RC_TIME_LIMIT_FEAS",
+                "KN_RC_FEVAL_LIMIT_FEAS",
+                "KN_RC_MIP_EXH_FEAS",
+                "KN_RC_MIP_TERM_FEAS",
+                "KN_RC_MIP_SOLVE_LIMIT_FEAS",
+                "KN_RC_MIP_NODE_LIMIT_FEAS",
+            ]
+            if solver_stats["return_status"] in list_feas_flags:
+                success = True
+
         return success, log_level
 
     @abstractproperty
@@ -589,19 +620,30 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
 
         return m, M
 
-    def bounds(self) -> AliasDict[str, Tuple[BT, BT]]:
+    @ensemble_bounds_check
+    def bounds(self, ensemble_member: Optional[int] = None) -> AliasDict[str, Tuple[BT, BT]]:
         """
         Returns variable bounds as a dictionary mapping variable names to a pair of bounds.
         A bound may be a constant, or a time series.
 
+        :param ensemble_member: The ensemble member index. Must be None (or not provided) when
+                               ensemble_specific_bounds is False. Must be an integer when
+                               ensemble_specific_bounds is True.
+
         :returns: A dictionary of variable names and ``(upper, lower)`` bound pairs.
                   The bounds may be numbers or :class:`.Timeseries` objects.
 
         Example::
-
+            # ensemble_specific_bounds is False
             def bounds(self):
                 return {'x': (1.0, 2.0), 'y': (2.0, 3.0)}
 
+            # ensemble_specific_bounds is True
+            def bounds(self, ensemble_member: int):
+                if ensemble_member == 0:
+                    return {'x': (1.0, 2.0), 'y': (2.0, 3.0)}
+                else:
+                    return {'x': (0.0, 3.0), 'y': (1.0, 4.0)}
         """
         return AliasDict(self.alias_relation)
 

rtctools/optimization/pi_mixin.py

@@ -285,8 +285,8 @@ class PIMixin(IOMixin):
         :param variable:        Time series ID.
         :param unit:            Unit.
         """
-        assert hasattr(
-            self, "_PIMixin__timeseries_import"
-        ), "set_unit can only be called after read() in pre() has finished."
+        assert hasattr(self, "_PIMixin__timeseries_import"), (
+            "set_unit can only be called after read() in pre() has finished."
+        )
         self.__timeseries_import.set_unit(variable, unit, 0)
         self.__timeseries_export.set_unit(variable, unit, 0)

rtctools/optimization/single_pass_goal_programming_mixin.py

@@ -2,11 +2,13 @@ import itertools
 import logging
 from collections import OrderedDict
 from enum import Enum
-from typing import Dict, Union
+from typing import Dict, Optional, Union
 
 import casadi as ca
 import numpy as np
 
+from rtctools._internal.ensemble_bounds_decorator import ensemble_bounds_check
+
 from .goal_programming_mixin import GoalProgrammingMixin
 from .goal_programming_mixin_base import (  # noqa: F401
     Goal,
@@ -109,8 +111,12 @@ class SinglePassGoalProgrammingMixin(_GoalProgrammingMixinBase):
     def path_variables(self):
         return self.__problem_path_epsilons
 
-    def bounds(self):
-        bounds = super().bounds()
+    @ensemble_bounds_check
+    def bounds(self, ensemble_member: Optional[int] = None):
+        bounds = (
+            super().bounds(ensemble_member) if self.ensemble_specific_bounds else super().bounds()
+        )
+
         for epsilon in self.__problem_epsilons + self.__problem_path_epsilons:
             bounds[epsilon.name()] = (0.0, 1.0)
         return bounds

rtctools/rtctoolsapp.py

@@ -1,9 +1,17 @@
+import importlib.resources
 import logging
 import os
 import shutil
 import sys
 from pathlib import Path
 
+# Python 3.9's importlib.metadata does not support the "group" parameter to
+# entry_points yet.
+if sys.version_info < (3, 10):
+    import importlib_metadata
+else:
+    from importlib import metadata as importlib_metadata
+
 import rtctools
 
 logging.basicConfig(format="%(asctime)s %(levelname)s %(message)s")
@@ -23,9 +31,6 @@ def copy_libraries(*args):
     if not os.path.exists(path):
         sys.exit("Folder '{}' does not exist".format(path))
 
-    # pkg_resources can be quite a slow import, so we do it here
-    import pkg_resources
-
     def _copytree(src, dst, symlinks=False, ignore=None):
         if not os.path.exists(dst):
             os.makedirs(dst)
@@ -56,11 +61,10 @@ def copy_libraries(*args):
     dst = Path(path)
 
     library_folders = []
-    for ep in pkg_resources.iter_entry_points(group="rtctools.libraries.modelica"):
+
+    for ep in importlib_metadata.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]))
-            )
+            library_folders.append(Path(importlib.resources.files(ep.module).joinpath(ep.attr)))
 
     tlds = {}
     for lf in library_folders:
@@ -100,11 +104,8 @@ def download_examples(*args):
     from zipfile import ZipFile
 
     version = rtctools.__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://github.com/deltares/rtc-tools/zipball/{}".format(version)
 
         opener = urllib.request.build_opener()
         urllib.request.install_opener(opener)
@@ -115,11 +116,12 @@ def download_examples(*args):
 
     with ZipFile(local_filename, "r") as z:
         target = path / "rtc-tools-examples"
-        prefix = "{}/examples/".format(rtc_full_name)
+        zip_folder_name = next(x for x in z.namelist() if x.startswith("Deltares-rtc-tools-"))
+        prefix = "{}/examples/".format(zip_folder_name.rstrip("/"))
         members = [x for x in z.namelist() if x.startswith(prefix)]
         z.extractall(members=members)
         shutil.move(prefix, target)
-        shutil.rmtree(rtc_full_name)
+        shutil.rmtree(zip_folder_name)
 
         sys.exit("Succesfully downloaded the RTC-Tools examples to '{}'".format(target.resolve()))
 

rtctools/simulation/io_mixin.py

@@ -94,7 +94,7 @@ class IOMixin(SimulationProblem, metaclass=ABCMeta):
             self.__cache_loop_timeseries = {}
 
             timeseries_names = set(self.io.get_timeseries_names(0))
-            for v in self.get_variables():
+            for v in self.get_input_variables():
                 if v in timeseries_names:
                     _, values = self.io.get_timeseries_sec(v)
                     self.__cache_loop_timeseries[v] = values

rtctools/simulation/pi_mixin.py

@@ -248,8 +248,8 @@ class PIMixin(IOMixin):
         :param variable:        Time series ID.
         :param unit:            Unit.
         """
-        assert hasattr(
-            self, "_PIMixin__timeseries_import"
-        ), "set_unit can only be called after read() in pre() has finished."
+        assert hasattr(self, "_PIMixin__timeseries_import"), (
+            "set_unit can only be called after read() in pre() has finished."
+        )
         self.__timeseries_import.set_unit(variable, unit, 0)
         self.__timeseries_export.set_unit(variable, unit, 0)

rtctools/simulation/simulation_problem.py

@@ -1,13 +1,21 @@
 import copy
+import importlib.resources
 import itertools
 import logging
 import math
+import sys
 from collections import OrderedDict
 from typing import List, Union
 
+# Python 3.9's importlib.metadata does not support the "group" parameter to
+# entry_points yet.
+if sys.version_info < (3, 10):
+    import importlib_metadata
+else:
+    from importlib import metadata as importlib_metadata
+
 import casadi as ca
 import numpy as np
-import pkg_resources
 import pymoca
 import pymoca.backends.casadi.api
 
@@ -492,8 +500,9 @@ class SimulationProblem(DataStoreAccessor):
                 self.set_var(var_name, numeric_start_val)
             except KeyError:
                 logger.warning(
-                    "Initialize: {} not found in state vector. "
-                    "Initial value of {} not set.".format(var_name, numeric_start_val)
+                    "Initialize: {} not found in state vector. Initial value of {} not set.".format(
+                        var_name, numeric_start_val
+                    )
                 )
 
             # Add a residual for the difference between the state and its starting expression
@@ -517,10 +526,14 @@ class SimulationProblem(DataStoreAccessor):
             # Check that the start_value is in between the variable bounds.
             if start_is_numeric and not min_is_symbolic and not max_is_symbolic:
                 if not (var.min <= start_val and start_val <= var.max):
-                    logger.warning(
-                        "Initialize: start value {} = {}".format(var_name, start_val)
-                        + " is not in between bounds {} and {}".format(var.min, var.max)
-                        + " and will be adjusted."
+                    logger.log(
+                        (
+                            logging.WARNING
+                            if source_description != "modelica file or default value"
+                            else logging.DEBUG
+                        ),
+                        f"Initialize: start value {var_name} = {start_val} "
+                        f"is not in between bounds {var.min} and {var.max} and will be adjusted.",
                     )
 
         # Default start var for ders is zero
@@ -1059,9 +1072,9 @@ class SimulationProblem(DataStoreAccessor):
         :param dt: Timestep size of the simulation.
         """
         if self._dt_is_fixed:
-            assert math.isclose(
-                self.__dt, dt
-            ), "Timestep size dt is marked as constant and cannot be changed."
+            assert math.isclose(self.__dt, dt), (
+                "Timestep size dt is marked as constant and cannot be changed."
+            )
         else:
             self.__dt = dt
 
@@ -1244,9 +1257,9 @@ class SimulationProblem(DataStoreAccessor):
         # Where imported model libraries are located.
         library_folders = self.modelica_library_folders.copy()
 
-        for ep in pkg_resources.iter_entry_points(group="rtctools.libraries.modelica"):
+        for ep in importlib_metadata.entry_points(group="rtctools.libraries.modelica"):
             if ep.name == "library_folder":
-                library_folders.append(pkg_resources.resource_filename(ep.module_name, ep.attrs[0]))
+                library_folders.append(str(importlib.resources.files(ep.module).joinpath(ep.attr)))
 
         compiler_options["library_folders"] = library_folders
 

rtctools/util.py

@@ -110,6 +110,7 @@ def run_optimization_problem(
             "GoalProgrammingMixin",
             "PIMixin",
             "CSVMixin",
+            "IOMixin",
             "ModelicaMixin",
             "PlanningMixin",
             "ControlTreeMixin",

rtctools/version.py

@@ -0,0 +1,51 @@
+"""Compute the version number and store it in the `__version__` variable.
+
+Based on <https://github.com/maresb/hatch-vcs-footgun-example>.
+"""
+
+
+def _get_hatch_version():
+    """Compute the most up-to-date version number in a development environment.
+
+    Returns `None` if Hatchling is not installed, e.g. in a production environment.
+
+    For more details, see <https://github.com/maresb/hatch-vcs-footgun-example/>.
+    """
+    import os
+
+    try:
+        import hatch_vcs  # noqa: F401
+        from hatchling.metadata.core import ProjectMetadata
+        from hatchling.plugin.manager import PluginManager
+        from hatchling.utils.fs import locate_file
+    except ImportError:
+        # Hatchling and/or hatch-vcs are not installed, so probably we are not
+        # in a development environment.
+        return None
+
+    pyproject_toml = locate_file(__file__, "pyproject.toml")
+    if pyproject_toml is None:
+        raise RuntimeError("pyproject.toml not found although hatchling is installed")
+    root = os.path.dirname(pyproject_toml)
+    metadata = ProjectMetadata(root=root, plugin_manager=PluginManager())
+    # Version can be either statically set in pyproject.toml or computed dynamically:
+    return metadata.core.version or metadata.hatch.version.cached
+
+
+def _get_importlib_metadata_version():
+    """Compute the version number using importlib.metadata.
+
+    This is the official Pythonic way to get the version number of an installed
+    package. However, it is only updated when a package is installed. Thus, if a
+    package is installed in editable mode, and a different version is checked out,
+    then the version number will not be updated.
+    """
+    from importlib.metadata import version
+
+    # NOTE: We cannot use `__package__` here, because our folder name is
+    # "rtctools", with our package name "rtc-tools" (with a dash).
+    __version__ = version("rtc-tools")
+    return __version__
+
+
+__version__ = _get_hatch_version() or _get_importlib_metadata_version()

rtc_tools-2.7.0.dev2.dist-info/METADATA

@@ -1,51 +0,0 @@
-Metadata-Version: 2.2
-Name: rtc-tools
-Version: 2.7.0.dev2
-Summary: Toolbox for control and optimization of water systems.
-Home-page: https://oss.deltares.nl/web/rtc-tools/home
-Download-URL: http://gitlab.com/deltares/rtc-tools/
-Author: Deltares
-Maintainer: Deltares
-Platform: Windows
-Platform: Linux
-Platform: Mac OS-X
-Platform: Unix
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Science/Research
-Classifier: Intended Audience :: Information Technology
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Scientific/Engineering :: GIS
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Classifier: Topic :: Scientific/Engineering :: Physics
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: POSIX
-Classifier: Operating System :: Unix
-Classifier: Operating System :: MacOS
-Requires-Python: >=3.9
-License-File: COPYING.LESSER
-Requires-Dist: casadi!=3.6.6,==3.6.*,>=3.6.3
-Requires-Dist: numpy>=1.16.0
-Requires-Dist: scipy>=1.0.0
-Requires-Dist: pymoca==0.9.*,>=0.9.1
-Requires-Dist: rtc-tools-channel-flow>=1.2.0
-Requires-Dist: defusedxml>=0.7.0
-Provides-Extra: netcdf
-Requires-Dist: netCDF4; extra == "netcdf"
-Provides-Extra: all
-Requires-Dist: netCDF4; extra == "all"
-Dynamic: author
-Dynamic: classifier
-Dynamic: description
-Dynamic: download-url
-Dynamic: home-page
-Dynamic: maintainer
-Dynamic: platform
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-RTC-Tools is the Deltares toolbox for control and optimization of water systems.
-

rtc_tools-2.7.0.dev2.dist-info/RECORD

@@ -1,50 +0,0 @@
-rtctools/__init__.py,sha256=91hvS2-ryd2Pvw0COpsUzTwJwSnTZ035REiej-1hNI4,107
-rtctools/_version.py,sha256=MKiTFKmzZzk3ruW9CeIqZv3Ttm1g0-MB9CDCLpfrPnw,502
-rtctools/rtctoolsapp.py,sha256=UnkuiJhv0crEEVs8H6PYvMuc2y_q6V_xLuyKEgXj9GM,4200
-rtctools/util.py,sha256=PaeKfDUA174ODZbY5fZjCTf-F-TdhW7yEuP189Ro190,9075
-rtctools/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rtctools/_internal/alias_tools.py,sha256=XuQSAhhFuVtwn0yrAObZWIKPsSF4j2axXRtEmitIFPs,5310
-rtctools/_internal/caching.py,sha256=p4gqSL7kCI7Hff-KjMEP7mhJCQSiU_lYm2MR7E18gBM,905
-rtctools/_internal/casadi_helpers.py,sha256=oAf5zyFkZbaMhvhgMnQkOi2A6dBOzj-VAUkYwBf-Jxk,1410
-rtctools/_internal/debug_check_helpers.py,sha256=UgQTEPw4PyR7MbYLewSSWQqTwQj7xr5yUBk820O9Kk4,1084
-rtctools/data/__init__.py,sha256=EllgSmCdrlvQZSd1VilvjPaeYJGhY9ErPiQtedmuFoA,157
-rtctools/data/csv.py,sha256=hEpoTH3nhZaAvRN4r-9-nYeAjaFiNDRoiZWg8GxM3yo,5539
-rtctools/data/netcdf.py,sha256=xpk4Ggl7gItNG6lO7p3OJPR-elK8_CiCtxUI7cX0gwk,19109
-rtctools/data/pi.py,sha256=5w50zWgI79Vu5EMMz-MKoManXYqsjxfFgcZN6Z3eeiQ,46638
-rtctools/data/rtc.py,sha256=1yGJZGq2Z36MYLiLuZaHnxupL4mgw-Wuu54PAG05kcM,9077
-rtctools/data/storage.py,sha256=67J4BRTl0AMEzlKNZ8Xdpy_4cGtwx8Lo_tL2n0G4S9w,13206
-rtctools/data/interpolation/__init__.py,sha256=GBubCIT5mFoSTV-lOk7cpwvZekNMEe5bvqSQJ9HE34M,73
-rtctools/data/interpolation/bspline.py,sha256=qevB842XWCH3fWlWMBqKMy1mw37ust-0YtSnb9PKCEc,948
-rtctools/data/interpolation/bspline1d.py,sha256=HAh7m5xLBuiFKzMzuYEqZX_GmCPChKjV7ynTS6iRZOc,6166
-rtctools/data/interpolation/bspline2d.py,sha256=ScmX0fPDxbUVtj3pbUE0L7UJocqroD_6fUT-4cvdRMc,1693
-rtctools/optimization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rtctools/optimization/collocated_integrated_optimization_problem.py,sha256=Bv1a1O4QTAdIpe9SOA9_oEDDph-oj-9q5yfN4SFMdW8,131343
-rtctools/optimization/control_tree_mixin.py,sha256=CC6TWp3kFQgMokx6213pRLx9iY17Fd0VcwG4Wpwa0Uo,8974
-rtctools/optimization/csv_lookup_table_mixin.py,sha256=h4WKuPR1BJbYuJfQ9lx4rXalB6yYK-zajINabRL7BrA,17298
-rtctools/optimization/csv_mixin.py,sha256=sRp5paHWfCw2bz-23Nw-HdFLS3CZTpVwaBdFo98DbvE,12252
-rtctools/optimization/goal_programming_mixin.py,sha256=r2pPzcqi-VlstPx4CdtUT0JeemduiYBV5zeH4kA9QGs,33301
-rtctools/optimization/goal_programming_mixin_base.py,sha256=IvA3cfJmUW9SaDGATD7r4Rrjku9T4oI2H68imPTlq2A,43816
-rtctools/optimization/homotopy_mixin.py,sha256=Kh0kMfxB-Fo1FBGW5tPOQk24Xx_Mmw_p0YuSQotdkMU,6905
-rtctools/optimization/initial_state_estimation_mixin.py,sha256=74QYfG-VYYTNVg-kAnCG6QoY3_sUmaID0ideF7bPkkY,3116
-rtctools/optimization/io_mixin.py,sha256=AsZQ7YOUcUbWoczmjTXaSje5MUEsPNbQyZBJ6qzSjzU,11821
-rtctools/optimization/linearization_mixin.py,sha256=mG5S7uwvwDydw-eBPyQKnLyKoy08EBjQh25vu97afhY,1049
-rtctools/optimization/linearized_order_goal_programming_mixin.py,sha256=LQ2qpYt0YGLpEoerif4FJ5wwzq16q--27bsRjcqIU5A,9087
-rtctools/optimization/min_abs_goal_programming_mixin.py,sha256=WMOv9EF8cfDJgTunzXfI_cUmBSQK26u1HJB_9EAarfM,14031
-rtctools/optimization/modelica_mixin.py,sha256=9MnZ2tz9WWMeUg7UuS7TNOuqvfZhuTDvZsDfS6HcBIo,17796
-rtctools/optimization/netcdf_mixin.py,sha256=-zkXh3sMYE50c3kHsrmUVGWMSFm-0cXQpGrCm0yn-Tc,7563
-rtctools/optimization/optimization_problem.py,sha256=qzpc81NaZMeoXKuayFmBF15iXYuNAk5yxmaER_Gcz_A,44131
-rtctools/optimization/pi_mixin.py,sha256=n_ZyifuNPxcRoJXKR6Ks7DgK_b7-EToYJ23_khOwpzo,11786
-rtctools/optimization/planning_mixin.py,sha256=O_Y74X8xZmaNZR4iYOe7BR06s9hnmcapbuHYHQTBPPQ,724
-rtctools/optimization/single_pass_goal_programming_mixin.py,sha256=Zb9szg3PGT2o6gkGsXluSfEaAswkw3TKfPQDzUrj_Y4,25784
-rtctools/optimization/timeseries.py,sha256=nCrsGCJThBMh9lvngEpbBDa834_QvklVvkxJqwX4a1M,1734
-rtctools/simulation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rtctools/simulation/csv_mixin.py,sha256=rGDUFPsqGHmF0_dWdXeWzWzMpkPmwCNweTBVrwSh31g,6704
-rtctools/simulation/io_mixin.py,sha256=SJasNGI--OQ9Y-Z61oeeaGCxSrNddYz4AOVfJYbmf74,6209
-rtctools/simulation/pi_mixin.py,sha256=vcizArZsOn7tGlSFCsUmkjmRFA1A1kMNqUllLlkVc9Y,9831
-rtctools/simulation/simulation_problem.py,sha256=8k3MjznzvFIut04NAiu7UAhfndAvNTkQFsO9vbmNd-0,49567
-rtc_tools-2.7.0.dev2.dist-info/COPYING.LESSER,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-rtc_tools-2.7.0.dev2.dist-info/METADATA,sha256=MKSiD7EB2VvL5lozEHyI4TSLh5tvIVAhgxr-6_QQkAw,1691
-rtc_tools-2.7.0.dev2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-rtc_tools-2.7.0.dev2.dist-info/entry_points.txt,sha256=DVS8sWf3b9ph9h8srEr6zmQ7ZKGwblwgZgGPZg-jRNQ,150
-rtc_tools-2.7.0.dev2.dist-info/top_level.txt,sha256=pnBrb58PFPd1kp1dqa-JHU7R55h3alDNJIJnF3Jf9Dw,9
-rtc_tools-2.7.0.dev2.dist-info/RECORD,,

rtc_tools-2.7.0.dev2.dist-info/top_level.txt

@@ -1 +0,0 @@
-rtctools

rtctools/_version.py

@@ -1,21 +0,0 @@
-
-# This file was generated by 'versioneer.py' (0.29) from
-# revision-control system data, or from the parent directory name of an
-# unpacked source archive. Distribution tarballs contain a pre-generated copy
-# of this file.
-
-import json
-
-version_json = '''
-{
- "date": "2025-02-04T13:27:11+0100",
- "dirty": false,
- "error": null,
- "full-revisionid": "3bdb1fdfd01f5ae5e4dff117abe8862d9316352a",
- "version": "2.7.0.dev2"
-}
-'''  # END VERSION_JSON
-
-
-def get_versions():
-    return json.loads(version_json)