progpy 1.6.0__tar.gz

progpy-1.6.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.1
+Name: progpy
+Version: 1.6.0
+Summary: The NASA Prognostic Package (ProgPy) is a python prognostics framework focused on building, using, and evaluating models and algorithms for prognostics (computation of remaining useful life) and health management of engineering systems, and provides a set of prognostics models for select components and prognostics algorithms developed within this framework, including uncertainty propagation.
+Home-page: https://nasa.github.io/progpy/
+Author: Christopher Teubert
+Author-email: christopher.a.teubert@nasa.gov
+License: NOSA
+Project-URL: Bug Reports, https://github.com/nasa/progpy/issues
+Project-URL: Docs, https://nasa.github.io/progpy/
+Project-URL: Organization, https://www.nasa.gov/content/diagnostics-prognostics
+Project-URL: Source, https://github.com/nasa/progpy
+Keywords: prognostics,diagnostics,fault detection,fdir,physics modeling,prognostics and health management,PHM,health management,surrogate modeling,model tuning,simulation,ivhm
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Manufacturing
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: License :: Other/Proprietary License 
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.7, <3.12
+Description-Content-Type: text/markdown
+Requires-Dist: scipy
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: requests
+Requires-Dist: chaospy
+Requires-Dist: fastdtw
+Requires-Dist: tensorflow; platform_system != "Darwin" or platform_machine != "arm64"
+Requires-Dist: tensorflow-macos; platform_system == "Darwin" and platform_machine == "arm64"
+Requires-Dist: filterpy
+
+# Prognostics Python Package (ProgPy)
+[![CodeFactor](https://www.codefactor.io/repository/github/nasa/progpy/badge)](https://www.codefactor.io/repository/github/nasa/progpy)
+[![GitHub License](https://img.shields.io/badge/License-NOSA-green)](https://github.com/nasa/progpy/blob/master/license.pdf)
+[![GitHub Releases](https://img.shields.io/github/release/nasa/progpy.svg)](https://github.com/nasa/progpy/releases)
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/nasa/progpy/HEAD?tutorial.ipynb)
+
+The NASA Prognostic Package (ProgPy) is a python prognostics framework focused on building, using, and evaluating models and algorithms for prognostics (computation of remaining useful life) and health management of engineering systems, and provides a set of prognostics models for select components and prognostics algorithms developed within this framework, suitable for use in prognostics for these components. It also includes algorithms for state estimation and prediction, including uncertainty propagation.
+
+ProgPy combines NASAs prog_models and prog_algs packages into a single python package, for simplicity and clarity.
+
+## Installation 
+`pip3 install progpy`
+
+## [Documentation](https://nasa.github.io/progpy/)
+See documentation [here](https://nasa.github.io/progpy/)
+ 
+## Repository Directory Structure 
+Here is the directory structure for the github repository 
+ 
+`src/progpy/` - The prognostics python package<br />
+`examples/` - Example Python scripts using progpy<br />
+`tests/` - Tests for progpy<br />
+`README.md` - The readme (this file)<br />
+`prog_model_template.py` - Template for Prognostics Model<br />
+`state_estimator_template.py` - Template for State Estimators<br />
+`predictor_template.py` - Template for Predictor<br />
+`tutorial.ipynb` - Tutorial (Juypter Notebook)
+
+## Citing this repository
+Use the following to cite this repository:
+
+```
+@misc{2023_nasa_progpy,
+  | author    = {Christopher Teubert and Katelyn Jarvis Griffith and Matteo Corbetta and Chetan Kulkarni and Portia Banerjee and Matthew Daigle},
+  | title     = {{ProgPy Python Prognostics Packages}},
+  | month     = Oct,
+  | year      = 2023,
+  | version   = {1.6},
+  | url       = {https://nasa.github.io/progpy}
+  | doi       = {10.5281/ZENODO.8097013}
+  | }
+```
+
+The corresponding reference should look like this:
+
+C. Teubert, K. Jarvis Griffith, M. Corbetta, C. Kulkarni, P. Banerjee, M. Daigle, ProgPy Python Prognostics Packages, v1.6, Oct 2023. URL https://github.com/nasa/progpy.
+
+## Contributing Organizations
+ProgPy was created by a partnership of multiple organizations, working together to build a set of high-quality prognostic tools for the wider PHM Community. We would like to give a big thank you for the ProgPy community, especially the following contributing organizations:
+
+* [NASA's Diagnostics and Prognostics Group](https://www.nasa.gov/content/diagnostics-prognostics)
+* German Aerospace Center (DLR)
+* Northrop Grumman Corporation (NGC)
+* Vanderbilt University
+
+## Acknowledgements
+The structure and algorithms of this package are strongly inspired by the [MATLAB Prognostics Model Library](https://github.com/nasa/PrognosticsModelLibrary), [MATLAB Prognostics Algorithm Library](https://github.com/nasa/PrognosticsAlgorithmLibrary), and the [MATLAB Prognostics Metrics Library](https://github.com/nasa/PrognosticsMetricsLibrary). We would like to recognize Matthew Daigle and the rest of the team that contributed to the Prognostics Models, Algorithms, and Metrics Libraries for the contributions their work on the MATLAB library made to the design of progpy.
+
+## Notices
+Copyright © 2021 United States Government as represented by the Administrator of the National Aeronautics and Space Administration.  All Rights Reserved.
+
+## Disclaimers
+No Warranty: THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE ERROR FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS, RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS RESULTING FROM USE OF THE SUBJECT SOFTWARE.  FURTHER, GOVERNMENT AGENCY DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE, IF PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT "AS IS."
+
+Waiver and Indemnity:  RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT.  IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS IN ANY LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH USE, INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM, RECIPIENT'S USE OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD HARMLESS THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW.  RECIPIENT'S SOLE REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE, UNILATERAL TERMINATION OF THIS AGREEMENT.

progpy-1.6.0/README.md

@@ -0,0 +1,65 @@
+# Prognostics Python Package (ProgPy)
+[![CodeFactor](https://www.codefactor.io/repository/github/nasa/progpy/badge)](https://www.codefactor.io/repository/github/nasa/progpy)
+[![GitHub License](https://img.shields.io/badge/License-NOSA-green)](https://github.com/nasa/progpy/blob/master/license.pdf)
+[![GitHub Releases](https://img.shields.io/github/release/nasa/progpy.svg)](https://github.com/nasa/progpy/releases)
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/nasa/progpy/HEAD?tutorial.ipynb)
+
+The NASA Prognostic Package (ProgPy) is a python prognostics framework focused on building, using, and evaluating models and algorithms for prognostics (computation of remaining useful life) and health management of engineering systems, and provides a set of prognostics models for select components and prognostics algorithms developed within this framework, suitable for use in prognostics for these components. It also includes algorithms for state estimation and prediction, including uncertainty propagation.
+
+ProgPy combines NASAs prog_models and prog_algs packages into a single python package, for simplicity and clarity.
+
+## Installation 
+`pip3 install progpy`
+
+## [Documentation](https://nasa.github.io/progpy/)
+See documentation [here](https://nasa.github.io/progpy/)
+ 
+## Repository Directory Structure 
+Here is the directory structure for the github repository 
+ 
+`src/progpy/` - The prognostics python package<br />
+`examples/` - Example Python scripts using progpy<br />
+`tests/` - Tests for progpy<br />
+`README.md` - The readme (this file)<br />
+`prog_model_template.py` - Template for Prognostics Model<br />
+`state_estimator_template.py` - Template for State Estimators<br />
+`predictor_template.py` - Template for Predictor<br />
+`tutorial.ipynb` - Tutorial (Juypter Notebook)
+
+## Citing this repository
+Use the following to cite this repository:
+
+```
+@misc{2023_nasa_progpy,
+  | author    = {Christopher Teubert and Katelyn Jarvis Griffith and Matteo Corbetta and Chetan Kulkarni and Portia Banerjee and Matthew Daigle},
+  | title     = {{ProgPy Python Prognostics Packages}},
+  | month     = Oct,
+  | year      = 2023,
+  | version   = {1.6},
+  | url       = {https://nasa.github.io/progpy}
+  | doi       = {10.5281/ZENODO.8097013}
+  | }
+```
+
+The corresponding reference should look like this:
+
+C. Teubert, K. Jarvis Griffith, M. Corbetta, C. Kulkarni, P. Banerjee, M. Daigle, ProgPy Python Prognostics Packages, v1.6, Oct 2023. URL https://github.com/nasa/progpy.
+
+## Contributing Organizations
+ProgPy was created by a partnership of multiple organizations, working together to build a set of high-quality prognostic tools for the wider PHM Community. We would like to give a big thank you for the ProgPy community, especially the following contributing organizations:
+
+* [NASA's Diagnostics and Prognostics Group](https://www.nasa.gov/content/diagnostics-prognostics)
+* German Aerospace Center (DLR)
+* Northrop Grumman Corporation (NGC)
+* Vanderbilt University
+
+## Acknowledgements
+The structure and algorithms of this package are strongly inspired by the [MATLAB Prognostics Model Library](https://github.com/nasa/PrognosticsModelLibrary), [MATLAB Prognostics Algorithm Library](https://github.com/nasa/PrognosticsAlgorithmLibrary), and the [MATLAB Prognostics Metrics Library](https://github.com/nasa/PrognosticsMetricsLibrary). We would like to recognize Matthew Daigle and the rest of the team that contributed to the Prognostics Models, Algorithms, and Metrics Libraries for the contributions their work on the MATLAB library made to the design of progpy.
+
+## Notices
+Copyright © 2021 United States Government as represented by the Administrator of the National Aeronautics and Space Administration.  All Rights Reserved.
+
+## Disclaimers
+No Warranty: THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE ERROR FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS, RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS RESULTING FROM USE OF THE SUBJECT SOFTWARE.  FURTHER, GOVERNMENT AGENCY DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE, IF PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT "AS IS."
+
+Waiver and Indemnity:  RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT.  IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS IN ANY LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH USE, INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM, RECIPIENT'S USE OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD HARMLESS THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW.  RECIPIENT'S SOLE REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE, UNILATERAL TERMINATION OF THIS AGREEMENT.

progpy-1.6.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

progpy-1.6.0/setup.py

@@ -0,0 +1,62 @@
+# Copyright © 2021 United States Government as represented by the Administrator of the
+# National Aeronautics and Space Administration.  All Rights Reserved.
+
+from setuptools import setup, find_packages
+import pathlib
+
+here = pathlib.Path(__file__).parent.resolve()
+
+# Get the long description from the README file
+long_description = (here / 'README.md').read_text(encoding='utf-8')
+
+INSTALL_REQS = [
+        'scipy',
+        'pandas',  # For data downloading features
+        'matplotlib',
+        'requests',  # For data downloading features
+        'chaospy',  # For PCE
+        'fastdtw',  # For DTW error calculation
+        "tensorflow; platform_system!='Darwin' or platform_machine!='arm64'",
+        "tensorflow-macos; platform_system=='Darwin' and platform_machine=='arm64'",
+        "filterpy",
+    ]
+
+setup(
+    name='progpy',
+    version='1.6.0',
+    description='The NASA Prognostic Package (ProgPy) is a python prognostics framework focused on building, using, and evaluating models and algorithms for prognostics (computation of remaining useful life) and health management of engineering systems, and provides a set of prognostics models for select components and prognostics algorithms developed within this framework, including uncertainty propagation.',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://nasa.github.io/progpy/',
+    author='Christopher Teubert',
+    author_email='christopher.a.teubert@nasa.gov',
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Science/Research',
+        'Intended Audience :: Developers',
+        'Intended Audience :: Manufacturing',
+        'Topic :: Scientific/Engineering',
+        'Topic :: Scientific/Engineering :: Artificial Intelligence',
+        'Topic :: Scientific/Engineering :: Physics',
+        'License :: Other/Proprietary License ',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3 :: Only'
+    ],
+    keywords=['prognostics', 'diagnostics', 'fault detection', 'fdir', 'physics modeling', 'prognostics and health management', 'PHM', 'health management', 'surrogate modeling', 'model tuning', 'simulation', 'ivhm'],
+    package_dir={"": "src"},
+    packages=find_packages(where='src'),
+    python_requires='>=3.7, <3.12',
+    install_requires=INSTALL_REQS,
+    license='NOSA',
+    project_urls={  # Optional
+        'Bug Reports': 'https://github.com/nasa/progpy/issues',
+        'Docs': 'https://nasa.github.io/progpy/',
+        'Organization': 'https://www.nasa.gov/content/diagnostics-prognostics',
+        'Source': 'https://github.com/nasa/progpy',
+    },
+)

progpy-1.6.0/src/progpy/__init__.py

@@ -0,0 +1,52 @@
+# Copyright © 2021 United States Government as represented by the Administrator of the National Aeronautics and Space Administration.  All Rights Reserved.
+
+__all__ = ['predictors', 'uncertain_data', 'state_estimators', 'run_prog_playback', 'metrics']
+
+from progpy.prognostics_model import PrognosticsModel
+from progpy.ensemble_model import EnsembleModel
+from progpy.composite_model import CompositeModel
+from progpy.mixture_of_experts import MixtureOfExpertsModel
+from progpy.linear_model import LinearModel
+from progpy import predictors, state_estimators, uncertain_data
+
+import warnings
+
+__version__ = '1.6.0'
+
+def run_prog_playback(obs, pred, future_loading, output_measurements, **kwargs):
+    warnings.warn("Depreciated in 1.2.0, will be removed in a future release.", DeprecationWarning)
+    config = {# Defaults
+        'predict_rate': 0, # Default- predict every step
+        'num_samples': 10,
+        'predict_config': {}
+    }
+    config.update(kwargs)
+
+    next_predict = output_measurements[0][0] + config['predict_rate']
+    times = []
+    inputs = []
+    states = []
+    outputs = []
+    event_states = []
+    toes = []
+    index = 0
+    for (t, measurement) in output_measurements:
+        obs.estimate(t, future_loading(t), measurement)
+        if t >= next_predict:
+            pred_results = pred.predict(obs.x.sample(config['num_samples']), future_loading, **config['predict_config'])
+            times.append(pred_results.times)
+            inputs.append(pred_results.inputs)
+            states.append(pred_results.states)
+            outputs.append(pred_results.outputs)
+            event_states.append(pred_results.event_states)
+            toes.append(pred_results.time_of_event)
+            index += 1
+            next_predict += config['predict_rate']
+    return predictors.PredictionResults(
+        times, 
+        inputs, 
+        states, 
+        outputs, 
+        event_states, 
+        toes
+    ) 

progpy-1.6.0/src/progpy/composite_model.py

@@ -0,0 +1,278 @@
+# Copyright © 2021 United States Government as represented by the Administrator of the
+# National Aeronautics and Space Administration.  All Rights Reserved.
+
+from collections.abc import Iterable
+
+from progpy import PrognosticsModel
+
+DIVIDER = '.'
+
+
+class CompositeModel(PrognosticsModel):
+    """
+    .. versionadded:: 1.5.0
+
+    A CompositeModel is a PrognosticsModel that is composed of multiple PrognosticsModels. This is a tool for modeling system-of-systems. I.e., interconnected systems, where the behavior and state of one system effects the state of another system. The composite prognostics models are connected using defined connections between the output or state of one model, and the input of another model. The resulting CompositeModel behaves as a single model.
+
+    Args:
+        models (list[PrognosticsModel] or list[tuple[str, PrognosticsModel]]):
+            A list of PrognosticsModels to be combined into a single model.
+            Provided in one of two forms:
+
+            1. A list of PrognosticsModels. The name of each model will be the class name. A number will be added for duplicates
+
+            2. A list of tuples where the first element is the model name and the second element is the model
+
+            Note: Order provided will be the order that models are executed
+        connections (list[tuple[str, str]], optional):
+            A list of tuples where the first element is the name of the output, state, or performance metrics of one model and the second element is the name of the input of another model.
+            The first element of the tuple must be of the form "model_name.output_name", "model_name.state_name", or "model_name.performance_metric_key".
+            The second element of the tuple must be of the form "model_name.input_name".
+            For example, if you have two models, "Batt1" and "Batt2", and you want to connect the output of "Batt1" to the input of "Batt2", you would use the following connection: ("Batt1.output", "Batt2.input")
+
+    Keyword Args:
+        outputs (list[str]):
+            Model outputs in format "model_name.output_name". Must be subset of all outputs from models. If not provided, all outputs will be included.
+    """
+
+    def __init__(self, models: list, connections: list = [], **kwargs):
+        # General Input Validation
+        if not isinstance(models, Iterable):
+            raise ValueError('The models argument must be a list')
+        if len(models) <= 1:
+            raise ValueError('The models argument must contain at least two models')
+        if not isinstance(connections, Iterable):
+            raise ValueError('The connections argument must be a list')
+
+        # Initialize
+        self.inputs = set()
+        self.states = set()
+        self.outputs = set()
+        self.events = set()
+        self.performance_metric_keys = set()
+        self.model_names = set()
+        duplicate_names = {}
+        kwargs['models'] = []
+
+        # Handle models
+        for m in models:
+            if isinstance(m, Iterable):
+                if len(m) != 2:
+                    raise ValueError('Each model tuple must be of the form (name: str, model). For example ("Batt1", BatteryElectroChem())')
+                if not isinstance(m[0], str):
+                    raise ValueError('The first element of each model tuple must be a string')
+                if not isinstance(m[1], PrognosticsModel):
+                    raise ValueError('The second element of each model tuple must be a PrognosticsModel')
+                if m[0] in self.model_names:
+                    duplicate_names[m[0]] = duplicate_names.get(m[0], 1) + 1
+                    m = (m[0] + '_' + str(duplicate_names[m[0]]), m[1])
+                self.model_names.add(m[0])
+                kwargs['models'].append(m)
+            elif isinstance(m, PrognosticsModel):
+                m = (m.__class__.__name__, m)
+                if m[0] in self.model_names:
+                    duplicate_names[m[0]] = duplicate_names.get(m[0], 1) + 1
+                    m = (m[0] + '_' + str(duplicate_names[m[0]]), m[1])
+                self.model_names.add(m[0])
+                kwargs['models'].append(m)
+            else:
+                raise ValueError(f'Each model must be a PrognosticsModel or tuple (name: str, PrognosticsModel), was {type(m)}')
+
+        for (name, m) in kwargs['models']:
+            self.inputs |= set([name + DIVIDER + u for u in m.inputs])
+            self.states |= set([name + DIVIDER + x for x in m.states])
+            self.outputs |= set([name + DIVIDER + z for z in m.outputs])
+            self.events |= set([name + DIVIDER + e for e in m.events])
+            self.performance_metric_keys |= set([name + DIVIDER + p for p in m.performance_metric_keys])
+        
+        # Handle outputs
+        if 'outputs' in kwargs:
+            if isinstance(kwargs['outputs'], str):
+                kwargs['outputs'] = [kwargs['outputs']]
+            if not isinstance(kwargs['outputs'], Iterable):
+                raise ValueError('The outputs argument must be a list[str]')
+            if not set(kwargs['outputs']).issubset(self.outputs):
+                raise ValueError('The outputs of the composite model must be a subset of the outputs of the models')
+            self.outputs = kwargs['outputs']
+        
+        # Handle Connections
+        kwargs['connections'] = []
+        self.__to_input_connections = {m_name: [] for m_name in self.model_names}
+        self.__to_state_connections = {m_name: [] for m_name in self.model_names}
+        self.__to_state_from_pm_connections = {m_name: [] for m_name in self.model_names}
+
+        for connection in connections:
+            # Input validation
+            if not isinstance(connection, Iterable) or len(connection) != 2:
+                raise ValueError('Each connection must be a tuple of the form (input: str, output: str)')
+            if not isinstance(connection[0], str) or not isinstance(connection[1], str):
+                raise ValueError('Each connection must be a tuple of the form (input: str, output: str)')
+
+            in_key, out_key = connection
+            # Validation
+            if out_key not in self.inputs:
+                raise ValueError(f'The output key, {out_key}, must be an input to one of the composite models. Options include {self.inputs}')
+
+            # Remove the out_key from inputs
+            # These no longer are an input to the composite model
+            # as they are now satisfied internally
+            self.inputs.remove(out_key)
+                
+            # Split the keys into parts (model, key_part)
+            (in_model, in_key_part) = in_key.split('.')
+            (out_model, out_key_part) = out_key.split('.')
+
+            # Validate parts
+            if in_model == out_model:
+                raise ValueError('The input and output models must be different')
+            if in_model not in self.model_names:
+                raise ValueError('The input model must be one of the models in the composite model')
+            if out_model not in self.model_names:
+                raise ValueError('The output model must be one of the models in the composite model')
+            
+            # Add to connections
+            if in_key in self.states:
+                self.__to_input_connections[out_model].append((in_key, out_key_part))
+            elif in_key in self.outputs:
+                # In output
+                self.__to_input_connections[out_model].append((in_key, out_key_part))
+
+                # Add to state (to preserve last between runs)
+                self.__to_state_connections[in_model].append((in_key_part, in_key))
+                self.states.add(in_key)
+            elif in_key in self.performance_metric_keys:
+                # In performance metric
+                self.__to_input_connections[out_model].append((in_key, out_key_part))
+
+                # Add to state (to preserve last between runs)
+                self.__to_state_from_pm_connections[out_model].append((in_key_part, in_key))
+                self.states.add(in_key)
+            else:
+                raise ValueError('The input key must be an output or state of one of the composite models')
+        
+        # Finish initialization
+        super().__init__(**kwargs)
+
+    def initialize(self, u={}, z={}):
+        if u is None:
+            u = {}
+        if z is None:
+            z = {}
+
+        x_0 = {}
+        # Initialize the models
+        for (name, m) in self.parameters['models']:
+            u_i = {key: u.get(name + '.' + key, None) for key in m.inputs}
+            z_i = {key: z.get(name + '.' + key, None) for key in m.outputs}
+            x_i = m.initialize(u_i, z_i)
+            for key, value in x_i.items():
+                x_0[name + '.' + key] = value
+        
+            # Process connections
+            # This initializes the states that are connected to outputs
+            for (in_key_part, in_key) in self.__to_state_connections[name]:
+                if in_key in z.keys():
+                    x_0[in_key] = z[in_key]
+                else:  # Missing from z, so estimate using initial state
+                    z_ii = m.output(x_i)
+                    x_0[in_key] = z_ii.get(in_key_part, None)
+
+            # This initializes the states that are connected to performance metrics
+            for (in_key_part, in_key) in self.__to_state_from_pm_connections[name]:
+                pm = m.performance_metrics(x_i)
+                x_0[in_key] = pm.get(in_key_part, None)
+                
+        return self.StateContainer(x_0)
+
+    def next_state(self, x, u, dt):
+        for (name, m) in self.parameters['models']:
+            # Prepare inputs
+            u_i = {key: u.get(name + '.' + key, None) for key in m.inputs}
+            # Process connections
+            # This updates the inputs that are connected to states/outputs
+            for (in_key, out_key_part) in self.__to_input_connections[name]:
+                u_i[out_key_part] = x[in_key]
+
+            u_i = m.InputContainer(u_i)
+            
+            # Prepare state
+            x_i = m.StateContainer({key: x[name + '.' + key] for key in m.states})
+
+            # Propagate state
+            x_next_i = m.next_state(x_i, u_i, dt)
+
+            # Save to super state
+            for key, value in x_next_i.items():
+                x[name + '.' + key] = value
+            
+            # Process connections
+            # This updates the states that are connected to outputs
+            if len(self.__to_state_connections[name]) > 0:
+                # From Outputs
+                z_i = m.output(x_next_i)
+                for (in_key_part, in_key) in self.__to_state_connections[name]:
+                    x[in_key] = z_i.get(in_key_part, None)
+
+            if len(self.__to_state_from_pm_connections) > 0:
+                # From Performance Metrics
+                pm_i = m.performance_metrics(x_next_i)
+                for (in_key_part, in_key) in self.__to_state_from_pm_connections[name]:
+                    x[in_key] = pm_i.get(in_key_part, None)
+
+        return x
+
+    def output(self, x):
+        z = {}
+        for (name, m) in self.parameters['models']:
+            # Prepare state
+            x_i = m.StateContainer({key: x[name + '.' + key] for key in m.states})
+
+            # Get outputs
+            z_i = m.output(x_i)
+
+            # Save to super outputs
+            for key, value in z_i.items():
+                z[name + '.' + key] = value
+        return self.OutputContainer(z)
+
+    def performance_metrics(self, x):
+        metrics = {}
+        for (name, m) in self.parameters['models']:
+            # Prepare state
+            x_i = m.StateContainer({key: x[name + '.' + key] for key in m.states})
+
+            # Get outputs
+            metrics_i = m.performance_metrics(x_i)
+
+            # Save to super outputs
+            for key, value in metrics_i.items():
+                metrics[name + '.' + key] = value
+        return metrics
+
+    def event_state(self, x):
+        e = {}
+        for (name, m) in self.parameters['models']:
+            # Prepare state
+            x_i = m.StateContainer({key: x[name + '.' + key] for key in m.states})
+
+            # Get outputs
+            e_i = m.event_state(x_i)
+
+            # Save to super outputs
+            for key, value in e_i.items():
+                e[name + '.' + key] = value
+        return e
+
+    def threshold_met(self, x):
+        tm = {}
+        for (name, m) in self.parameters['models']:
+            # Prepare state
+            x_i = m.StateContainer({key: x[name + '.' + key] for key in m.states})
+
+            # Get outputs
+            tm_i = m.threshold_met(x_i)
+
+            # Save to super outputs
+            for key, value in tm_i.items():
+                tm[name + '.' + key] = value
+        return tm

progpy-1.6.0/src/progpy/data_models/__init__.py

@@ -0,0 +1,13 @@
+# Copyright © 2021 United States Government as represented by the Administrator of the
+# National Aeronautics and Space Administration.  All Rights Reserved.
+
+from .data_model import DataModel
+from .dmd import DMDModel
+from .lstm_model import LSTMStateTransitionModel
+from .pce import PolynomialChaosExpansion, PCE
+
+SURROGATE_METHOD_LOOKUP = {
+    'dmd': DMDModel.from_model,
+    'lstm': LSTMStateTransitionModel.from_model,
+    'pce': PolynomialChaosExpansion.from_model,
+}