engforge 0.3.0__py3-none-any.whl

engforge/test/test_solver.py

@@ -0,0 +1,343 @@
+import unittest
+from engforge._testing_components import *
+from engforge.problem_context import ProblemExec
+import itertools
+
+
+indep = "*x,*y,*z"
+indep_l = indep.split(",")
+
+
+class SolverRefSelection(unittest.TestCase):
+    def setUp(self) -> None:
+        self.sc = CubeSystem()
+
+    def test_comps_solver_act(self):
+        inv = "ineq_cost,ineq_length,min_len" + "," + indep
+        acts = ["*costA", "*lenA"]
+        for act in [True, False]:
+            for cmb in [inv, inv.split(",")]:
+                extra = dict(
+                    combos=cmb,
+                    slv_vars="*",
+                    activate=acts if act else None,
+                    only_active=act,
+                )
+                info = self.sc.solver_vars(**extra)["attrs"]
+                ans = {"x", "y", "z", "comp.x", "comp.y", "comp.z"}
+                self.assertEqual(set(info["solver.var"]), ans)
+                self.assertEqual(set(info["dynamics.state"]), ans)
+                self.assertEqual(set(info["dynamics.rate"]), ans)
+
+                empt = ["solver.eq", "solver.obj", "time", "slot", "signal"]
+                for emp in empt:
+                    self.assertEqual(info[emp], {})
+
+                if act:
+                    ineq = {"comp.lenA", "comp.costA", "costA", "lenA"}
+                    self.assertEqual(set(info["solver.ineq"]), ineq)
+
+    def test_comps_solver_obj(self):
+        inv = "obj_size,ineq_cost,ineq_length,min_len" + "," + indep
+        acts = ["*costA", "*lenA"]
+        aacts = ["*costA", "*lenA", "*size"]
+        for act in [True, False]:
+            for cmb in [inv, inv.split(",")]:
+                actv = acts if act else aacts
+                extra = dict(combos=cmb, slv_vars="*", activate=actv, only_active=True)
+                info = self.sc.solver_vars(**extra)["attrs"]
+                ans = {"x", "y", "z", "comp.x", "comp.y", "comp.z"}
+                self.assertEqual(set(info["solver.var"]), ans)
+                self.assertEqual(set(info["dynamics.state"]), ans)
+                self.assertEqual(set(info["dynamics.rate"]), ans)
+
+                ineq = {"comp.lenA", "comp.costA", "costA", "lenA"}
+                self.assertEqual(set(info["solver.ineq"]), ineq)
+
+                empt = ["solver.eq", "time", "slot", "signal"]
+                for emp in empt:
+                    self.assertEqual(info[emp], {})
+
+                if not act:
+                    obj = {"size", "comp.size"}
+                    self.assertEqual(set(info["solver.obj"]), obj)
+                else:
+                    self.assertEqual(set(info["solver.obj"]), set())
+
+    def test_sys_solver(self):
+        # test combos
+        inv = "volume,height,min_len,total_*" + "," + indep
+        for act in [True, False]:
+            for cmb in [inv, inv.split(",")]:
+                extra = dict(
+                    combos=cmb,
+                    slv_vars=indep + ",hght,obj,*sys*",
+                    activate=[],
+                    only_active=act,
+                )
+                info = self.sc.solver_vars(**extra)["attrs"]
+                ans = {"x", "y", "z", "comp.x", "comp.y", "comp.z"}
+                self.assertEqual(set(info["solver.var"]), ans)
+                self.assertEqual(set(info["dynamics.state"]), ans)
+                self.assertEqual(set(info["dynamics.rate"]), ans)
+
+                obj = {"hght", "obj"}
+                self.assertEqual(set(info["solver.obj"]), obj)
+                ineq = {"sys_budget", "sys_length"}
+                self.assertEqual(set(info["solver.ineq"]), ineq)
+
+                empt = ["solver.eq", "time", "slot", "signal"]
+                for emp in empt:
+                    self.assertEqual(info[emp], {})
+
+    def test_xyz_var_only(self):
+        """only xyz via vars"""
+        inv = indep
+        for act in [True, False]:
+            for cmb in [inv, inv.split(",")]:
+                extra = dict(combos=None, slv_vars=cmb, only_active=act)
+                info = self.sc.solver_vars(**extra)["attrs"]
+                ans = {"x", "y", "z", "comp.x", "comp.y", "comp.z"}
+                self.assertEqual(set(info["solver.var"]), ans)
+                self.assertEqual(set(info["dynamics.state"]), ans)
+                self.assertEqual(set(info["dynamics.rate"]), ans)
+
+                empt = [
+                    "solver.eq",
+                    "solver.ineq",
+                    "solver.obj",
+                    "time",
+                    "slot",
+                    "signal",
+                ]
+                for emp in empt:
+                    self.assertEqual(info[emp], {})
+
+    def test_xyz_combo_only(self):
+        """only xyz via combos"""
+        inv = "x,y,z"
+        for act in [True, False]:
+            for cmb in [inv, inv.split(",")]:
+                extra = dict(combos=None, slv_vars=indep, only_active=act)
+                info = self.sc.solver_vars(**extra)["attrs"]
+                ans = {"x", "y", "z", "comp.x", "comp.y", "comp.z"}
+                self.assertEqual(set(info["solver.var"]), ans)
+                self.assertEqual(set(info["dynamics.state"]), ans)
+                self.assertEqual(set(info["dynamics.rate"]), ans)
+
+                empt = [
+                    "solver.eq",
+                    "solver.ineq",
+                    "solver.obj",
+                    "time",
+                    "slot",
+                    "signal",
+                ]
+                for emp in empt:
+                    self.assertEqual(info[emp], {})
+
+    def test_xyz_act_nocombo(self):
+        """activated aren't included because no combos are given"""
+        extra = dict(
+            combos=None,
+            slv_vars=indep,
+            activate=["*costA", "*lenA", "*size"],
+            only_active=True,
+        )
+
+        info = self.sc.solver_vars(**extra)["attrs"]
+        ans = {"x", "y", "z", "comp.x", "comp.y", "comp.z"}
+        self.assertEqual(set(info["solver.var"]), ans)
+        self.assertEqual(set(info["dynamics.state"]), ans)
+        self.assertEqual(set(info["dynamics.rate"]), ans)
+
+        empt = [
+            "solver.eq",
+            "solver.ineq",
+            "solver.obj",
+            "time",
+            "slot",
+            "signal",
+        ]
+        for emp in empt:
+            self.assertEqual(info[emp], {})
+
+
+import pprint
+
+
+class SingleCompSolverTest(unittest.TestCase):
+    inequality_min = -1e-6
+
+    def setUp(self) -> None:
+        self.sc = CubeSystem(comp=CubeComp())
+
+    def test_exec_results(self):
+        extra = dict(combos=indep_l, slv_vars=indep, activate=[], only_active=True)
+        with ProblemExec(self.sc, extra) as pb:
+            o = self.sc.execute(**extra)
+            self.assertDictEqual(o["Xstart"], o["Xans"])
+
+    def test_run_results(self):
+        """test that inputs stay the same when no objecives present"""
+        extra = dict(combos=indep, slv_vars=indep_l, activate=[], only_active=True)
+
+        scx, scy, scz = self.sc.x, self.sc.y, self.sc.z
+        sccx, sccy, sccz = self.sc.comp.x, self.sc.comp.y, self.sc.comp.z
+        vray = [scx, scy, scz, sccx, sccy, sccz]
+
+        o = self.sc.run(**extra)
+
+        # dfray = self.sc.dataframe[['x','y','z','comp_x','comp_y','comp_z']].iloc[0].values
+        # self.assertFalse(np.all(dfray==vray),msg=f'{dfray}\n{vray}')
+
+        scx, scy, scz = self.sc.x, self.sc.y, self.sc.z
+        sccx, sccy, sccz = self.sc.comp.x, self.sc.comp.y, self.sc.comp.z
+        v2ray = [scx, scy, scz, sccx, sccy, sccz]
+
+        self.assertTrue(np.all(vray == v2ray), msg="revert values changed!")
+
+    def test_comp_method_equivalence(self):
+        objs = {"obj_eff": ["eff", "effF"], "obj_size": ["size", "sizeF"]}
+        cons = {
+            "ineq_cost": ["costA", "costF", "costP"],
+            "ineq_length": ["lenA", "lenF", "lenP"],
+        }
+
+        for ok, ck in itertools.product(objs, cons):
+            attempts = []
+            for var in objs[ok]:
+                for con in cons[ck]:
+                    extra = dict(
+                        combos=[ok, ck, "min_len"],
+                        slv_vars=indep,
+                        activate=[var, con],
+                        only_active=True,
+                        both_match=False,
+                    )
+                    o = self.sc.execute(**extra)
+                    attempts.append(o)
+
+            # check for equivalence
+            a0 = attempts[0]
+            for atmpt in attempts[1:]:
+                ak1 = a0["Xans"]
+                ak2 = atmpt["Xans"]
+                self.assertEqual(set(ak1), set(ak2))
+                for k in ak1:
+                    self.assertAlmostEqual(ak1[k], ak2[k], places=4)
+
+    def test_system_execute(self):
+        """check the system solver methods work as expected (objectives are optimized)"""
+        extra = dict(
+            combos="volume,height,min_len,total_*",
+            slv_vars=indep,
+            activate=[],
+            only_active=True,
+            both_match=False,
+        )
+
+        H = self.sc.execute(**extra, weights={"hght": 1, "obj": 0})
+        V = self.sc.execute(**extra, weights={"hght": 0, "obj": 1})
+
+        self.assertGreater(H["Yobj"]["hght"], V["Yobj"]["hght"])
+        self.assertGreater(V["Yobj"]["obj"], H["Yobj"]["obj"])
+
+    def test_system_run(self):
+        """check the system solver methods work as expected (objectives are optimized)"""
+        extra = dict(
+            combos="volume,height,min_len,total_*",
+            slv_vars=indep,
+            activate=[],
+            only_active=True,
+            both_match=False,
+        )
+
+        H = self.sc.run(**extra, weights={"hght": 1, "obj": 0})["output"][0]
+        V = self.sc.run(**extra, weights={"hght": 0, "obj": 1})["output"][0]
+
+        self.assertGreater(H["Yobj"]["hght"], V["Yobj"]["hght"])
+        self.assertGreater(V["Yobj"]["obj"], H["Yobj"]["obj"])
+
+    def test_system_solver(self):
+        """check the system solver methods work as expected (objectives are optimized)"""
+        extra = dict(
+            combos="volume,height,min_len,total_*",
+            slv_vars=indep,
+            activate=[],
+            only_active=True,
+            both_match=False,
+        )
+
+        H = self.sc.solver(**extra, weights={"hght": 1, "obj": 0})
+        V = self.sc.solver(**extra, weights={"hght": 0, "obj": 1})
+
+        self.assertGreater(H["Yobj"]["hght"], V["Yobj"]["hght"])
+        self.assertGreater(V["Yobj"]["obj"], H["Yobj"]["obj"])
+
+    def test_system_eval(self):
+        """check the system solver methods work as expected (objectives are optimized)"""
+        extra = dict(
+            combos="volume,height,min_len,total_*",
+            slv_vars=indep,
+            activate=[],
+            only_active=True,
+            both_match=False,
+        )
+
+        H = self.sc.eval(**extra, weights={"hght": 1, "obj": 0})
+        V = self.sc.eval(**extra, weights={"hght": 0, "obj": 1})
+
+        self.assertGreater(H["Yobj"]["hght"], V["Yobj"]["hght"])
+        self.assertGreater(V["Yobj"]["obj"], H["Yobj"]["obj"])
+
+
+# TODO: rewrite these tests
+#     def test_selective_exec(self):
+#         extra = dict(combos='*fun*,goal',ign_combos=['z_sym_eq','*size*','*eff*'])
+#         o = self.sc.execute(**extra)
+#         res = self.test_results(o)
+#         self.test_selection(o,res,extra)
+#
+#     def test_runmtx(self):
+#         extra = dict(budget=[100,500,1000],max_length=[50,100,200])
+#         o = self.sc.run(**extra)
+#         res = self.test_results(o)
+#         df = self.test_dataframe(o)
+#         self.test_selection(o,res,extra)
+#
+#     def test_selective_runmtx(self):
+#         extra = dict(budget=[100,500,1000],max_length=[50,100,200],combos='*fun*,goal',ign_combos=['z_sym_eq','*size*','*eff*'])
+#         o = self.sc.run(**extra)
+#         res = self.test_results(o)
+#         df = self.test_dataframe(o)
+#         self.test_selection(o,res,extra)
+#
+#     def test_run_wildcard(self):
+#         extra = dict(combos='*fun*,goal',ign_combos='*',budget=[100,500,1000],max_length=[50,100,200])
+#         o = self.sc.run(**extra)
+#         res = self.test_results(o)
+#         df = self.test_dataframe(o)
+#         self.test_selection(o,res,extra)
+#
+#     #Checks
+#     def test_dataframe(self,results)->dict:
+#         #print(results)
+#         print(NotImplementedError("#FIXME!"))
+#
+#     def test_selection(self,results,df_res,extra):
+#         #print(results,df_res,extra)
+#         print(NotImplementedError("#FIXME!"))
+#
+#     def test_results(self,results):
+#         Ycon = results['Ycon']
+#         costmg = {k:v for k,v in Ycon.items() if 'cost' in k}
+#         lenmg = {k:v for k,v in Ycon.items() if 'len' in k}
+#
+#         #Test input equivalence of methods
+#         self.assertEqual(len(set(costmg.values())),1)
+#         self.assertEqual(len(set(lenmg.values())),1)
+#
+#         #Test inequality constraints
+#         yvals = (v >= self.inequality_min for v in Ycon.values())
+#         self.assertTrue(all(yvals))

engforge/test/test_tabulation.py

@@ -0,0 +1,233 @@
+import unittest
+import io
+import tempfile
+
+from engforge.configuration import forge
+from engforge.tabulation import system_property
+from engforge.components import Component
+from engforge.system import System
+from engforge.component_collections import ComponentIterator, ComponentDict
+from engforge.problem_context import ProblemExec
+import attr
+import os
+import numpy
+import random
+
+from pprint import pprint
+
+# from engforge.logging import LoggingMixin, change_all_log_levels
+# change_all_log_levels(10)
+
+
+@forge
+class TestConfig(System):
+    attrs_prop: float = attr.ib(1.0)
+    attrs_str: str = attr.ib("hey now")
+
+    @system_property
+    def test_one(self) -> int:
+        return 1
+
+    @system_property(stochastic=True)
+    def test_two(self) -> float:
+        return random.random()
+
+    @system_property(label="three", desc="some words")
+    def test_three(self) -> int:
+        return 2
+
+    @system_property(label="four", desc="would make sense", stochastic=True)
+    def test_four(self) -> float:
+        return random.random()
+
+
+class Test(unittest.TestCase):
+    test_file_name = "test_dataframe_file"
+    test_dir = "~/"
+
+    def setUp(self):
+        self.test_config = TestConfig(name="testconfig")
+
+    #         self.test_dir = tempfile.mkdtemp()
+    #
+    #     def tearDown(self):
+    #         contents_local = os.listdir(self.test_dir)
+    #         for fil in contents_local:
+    #             if self.test_file_name in fil:
+    #                 rfil = os.path.join(self.test_dir, fil)
+
+    def test_property_labels(self):
+        ans = set(["four", "test_two", "test_one", "three", "converged", "run_id"])
+        self.assertEqual(set(self.test_config.system_properties_labels), ans)
+
+    def test_property_types(self):
+        ans = [int, float, int, float, int, int]
+        self.assertEqual(self.test_config.system_properties_types, ans)
+
+    def test_property_desc(self):
+        ans = ["", "", "some words", "would make sense", "", ""]
+        self.assertEqual(self.test_config.system_properties_description, ans)
+
+    def test_table_vals(self):
+        vals_ans = (1, 2)
+        for val in vals_ans:
+            self.assertTrue(
+                any(
+                    [
+                        val == valcan if type(valcan) is int else False
+                        for valcan in self.test_config.system_properties
+                    ]
+                )
+            )
+
+    def test_assemble_data_always_save(self):
+        self.test_config.info(
+            f"testing data assembly {self.test_config.always_save_data}"
+        )
+        self.test_config._always_save_data = True
+        # Run before test_table_to...
+        self.assertFalse(self.test_config.dataframe.shape[0])
+        with ProblemExec(self.test_config, {}) as px:
+            px.save_data()
+
+            self.assertTrue(px.dataframe.shape[0])
+            self.assertTrue(1 == px.dataframe.shape[0])
+
+            # Stochastic Props so this will work without input change.
+            px.save_data()
+            self.assertTrue(2 == px.dataframe.shape[0])
+
+    def test_assemble_data_on_input(self):
+        # change this to check behavior to adjust stochastic behavior
+        # print(f"testing data assembly {self.test_config.always_save_data}")
+        # Run before test_table_to...
+        self.assertFalse(self.test_config.dataframe.shape[0])
+        self.test_config._always_save_data = False
+        self.test_config.info(
+            f"testing data assembly {self.test_config.always_save_data}"
+        )
+
+        with ProblemExec(self.test_config, {}) as px:
+            px.save_data()
+
+            # print(px.dataframe,len(px.dataframe))
+            self.assertTrue(px.dataframe.shape[0])
+            self.assertTrue(1 == px.dataframe.shape[0])
+
+            # No Update So This Wont Save
+            px.save_data()
+            self.assertFalse(2 == px.dataframe.shape[0])
+
+            # Change Something
+            cur_val = self.test_config.attrs_prop
+            new_val = 6 + cur_val
+            self.test_config.info(f"setting attrs prop on in {cur_val } => {new_val}")
+
+            self.test_config.attrs_prop = new_val
+            px.save_data()
+            self.assertTrue(2 == px.dataframe.shape[0])
+
+    def test_dataframe(self, iter=5):
+        attr_in = {}
+        cur_dict = self.test_config.data_dict
+        with ProblemExec(self.test_config, {}) as px:
+            for i in range(iter):
+                with ProblemExec(self.test_config, {}) as px:
+                    cur_val = self.test_config.attrs_prop
+                    attr_in[i] = val = cur_val + i**2.0
+                    self.test_config.info(f"setting attrs prop df {cur_val } => {val}")
+                    self.test_config.attrs_prop = val
+                    px.save_data()
+                    px.exit_with_state()
+                postdict = self.test_config.data_dict
+                self.assertDictEqual(cur_dict, postdict)
+            px.exit_with_state()
+
+        postdict = self.test_config.data_dict
+        # self.test_config.info(f'cur_dict {cur_dict} postdict {postdict}')
+        self.assertDictEqual(cur_dict, postdict)
+
+        df = self.test_config.dataframe
+        pprint(df)
+
+        self.assertEqual(len(df.index), iter)
+
+        self.assertEqual(df["test_one"].max(), 1)
+        self.assertEqual(df["test_one"].min(), 1)
+
+        self.assertEqual(df["test_three"].max(), 2)
+        self.assertEqual(df["test_three"].min(), 2)
+
+        l1 = list(df["attrs_prop"])
+        l2 = [attr_in[i] for i in range(iter)]
+        self.assertListEqual(l1, l2)
+
+
+# TODO: move these to reporting
+# def file_in_format(self, fileextension, path=True):
+#     fille = "{}.{}".format(self.test_file_name, fileextension)
+#     if path:
+#         path = os.path.join(self.test_dir, fille)
+#         return path
+#     else:
+#         return fille
+#     def test_table_to_csv(self):
+#         pass
+#         print('saving '+self.file_in_format('xlsx'))
+#         self.test_config.save_csv(self.file_in_format('csv'))
+#         self.assertIn(self.file_in_format('csv',False), os.listdir(self.test_dir))
+
+#
+#     def test_table_to_excel(self):
+#         pass
+#         #print('saving '+self.file_in_format('xlsx'))
+#         #self.test_config.save_excel(self.file_in_format('xlsx'))
+#         #self.assertIn(self.file_in_format('xlsx',False),os.listdir(self.test_dir))
+#
+#     def test_table_to_gsheets(self):
+#         pass
+#
+#     def test_table_to_db(self):
+#         pass
+
+
+@forge
+class Static(System):
+    attrs_prop: float = attr.ib(1.0)
+    attrs_str: str = attr.ib("hey now")
+
+    @system_property
+    def test_one(self) -> int:
+        return 1
+
+    @system_property()
+    def test_two(self) -> int:
+        return 2
+
+
+class TestStatic(unittest.TestCase):
+    def setUp(self):
+        self.test_config = Static()
+
+    def test_static(self, num=10):
+        cur_dict = self.test_config.data_dict
+        with ProblemExec(self.test_config, {}) as px:
+            for i in range(num):
+                with ProblemExec(self.test_config, {}) as px:
+                    px.save_data()
+                postdict = self.test_config.data_dict
+                self.assertDictEqual(cur_dict, postdict)
+
+        self.assertEqual(len(self.test_config.dataframe), 1)
+
+    def test_input(self, num=10):
+        cur_dict = self.test_config.data_dict
+        with ProblemExec(self.test_config, {}) as px:
+            for i in range(num):
+                with ProblemExec(self.test_config, {}) as px:
+                    self.test_config.attrs_prop = i + self.test_config.attrs_prop
+                    px.save_data()
+                postdict = self.test_config.data_dict
+                self.assertDictEqual(cur_dict, postdict)
+
+        self.assertEqual(len(self.test_config.dataframe), num)

engforge/typing.py

@@ -0,0 +1,92 @@
+""" """
+
+import pandas, attr, numpy
+from engforge.properties import *
+import attrs
+
+# import matplotlib.pyplot as plt
+pandas.set_option("use_inf_as_na", True)
+
+# Type Checking
+NUMERIC_TYPES = (float, int, numpy.int64, numpy.float64)
+NUMERIC_NAN_TYPES = (float, int, type(None), numpy.int64, numpy.float64)
+STR_TYPES = (str, numpy.string_)
+TABLE_TYPES = (int, float, str, type(None), numpy.int64, numpy.float64)
+
+
+# TODO: add min / max args & attrs boilerplate
+def NUMERIC_VALIDATOR():
+    return attr.validators.instance_of(NUMERIC_TYPES)
+
+
+def NUMERIC_NAN_VALIDATOR():
+    return attr.validators.instance_of(NUMERIC_NAN_TYPES)
+
+
+def STR_VALIDATOR():
+    return attr.validators.instance_of(STR_TYPES)
+
+
+ATTR_VALIDATOR_TYPES = (
+    attr.validators._AndValidator,
+    attr.validators._InstanceOfValidator,
+    attr.validators._MatchesReValidator,
+    attr.validators._ProvidesValidator,
+    attr.validators._OptionalValidator,
+    attr.validators._InValidator,
+    attr.validators._IsCallableValidator,
+    attr.validators._DeepIterable,
+    attr.validators._DeepMapping,
+)
+
+TAB_VALIDATOR_TYPE = (
+    attr.validators._InstanceOfValidator
+)  # our validators should require a type i think, at least for tabulation
+
+
+# Improved Attrs Creation Fields
+def Options(*choices, **kwargs):
+    """creates an attrs field with validated choices on init and setattr
+    :param choices: a list of choices that are validated on input, the first becoming the default unless it is passed in kwargs
+    :param kwargs: keyword args passed to attrs field"""
+    assert choices, f"must have some choices!"
+    assert "type" not in kwargs, "options type set is str"
+    valids = set((str, int, float, bool, type(None)))
+    assert set([type(c) for c in choices]).issubset(
+        valids
+    ), f"choices must be in {valids}"
+    assert "on_setattr" not in kwargs
+
+    validators = [attrs.validators.in_(choices)]
+
+    # Merge Validators
+    if "validators" in kwargs:
+        in_validators = kwargs.pop("validators")
+        if isinstance(in_validators, list):
+            validators.extend(in_validators)
+        elif isinstance(in_validators, attr.validators._ValidatorType):
+            validators.append(in_validators)
+        else:
+            raise ValueError(f"bad validator {in_validators}")
+
+    # Default
+    if "default" in kwargs:
+        default = kwargs.pop("default")
+        assert type(default) is str
+    else:
+        default = choices[0]
+
+    on_setattr = [attrs.setters.validate]
+
+    # Create The Attr!
+    a = attrs.field(
+        default=default,
+        type=str,
+        validator=validators,
+        on_setattr=on_setattr,
+        **kwargs,
+    )
+    return a
+
+
+# def Numeric #TODO with min/max that is enforced in solver!