engforge 0.3.0__py3-none-any.whl

engforge/analysis.py

@@ -0,0 +1,257 @@
+import attr
+from engforge.configuration import forge, Configuration
+from engforge.components import Component
+from engforge.tabulation import TabulationMixin, DataframeMixin
+from engforge.system import System
+from engforge.typing import *
+from engforge.reporting import *
+from engforge.attr_plotting import PlottingMixin
+
+
+# import datetime
+import os
+from uuid import uuid4
+
+import random
+import attrs
+
+from contextlib import contextmanager
+import inspect
+
+import matplotlib.pylab as pylab
+
+list_check = attrs.validators.instance_of(list)
+
+
+def make_reporter_check(type_to_check):
+    def reporter_type_check(inst, attr, value):
+        if not isinstance(value, list):
+            raise ValueError("must be a list!")
+
+        if not all([isinstance(v, type_to_check) for v in value]):
+            raise ValueError("must be a list of type {value.__name__}!")
+
+    return reporter_type_check
+
+
+@forge
+class Analysis(Configuration, TabulationMixin, PlottingMixin, DataframeMixin):
+    """Analysis takes a system and many reporters, runs the system, adds its own system properties to the dataframe and post processes the results
+
+    make_plots() makes plots from the analysis, and stores figure
+    post_process()  but can be overriden
+    report_results() writes to reporters
+    """
+
+    # TODO: generate pdf with tables ect.
+
+    system: System = attrs.field()
+    table_reporters: list = attrs.field(
+        factory=list, validator=make_reporter_check(TableReporter)
+    )
+    plot_reporters: list = attrs.field(
+        factory=list, validator=make_reporter_check(PlotReporter)
+    )
+
+    _stored_plots: dict = attrs.field(factory=dict)
+    _uploaded = False
+
+    show_plots: bool = attrs.field(default=True)
+
+    @property
+    def uploaded(self):
+        return self._uploaded
+
+    def run(self, *args, **kwargs):
+        """Analysis.run() passes inputs to the assigned system and saves data via the system.run(cb=callback), once complete `Analysis.post_process()` is run also being passed input arguments, then plots & reports are made"""
+        self.info(f"running analysis {self.identity} with input {args} {kwargs}")
+        cb = lambda *args, **kw: self.system.last_context.save_data(force=True)
+        out = self.system.run(*args, **kwargs, cb=cb)
+        self.post_process(*args, **kwargs)
+
+        self._stored_plots = {}
+        self.make_plots(analysis=self, store_figures=self._stored_plots)
+        self.report_results()
+
+    def post_process(self, *args, **kwargs):
+        """A user customizeable function"""
+        pass
+
+    def report_results(self):
+        self.info(f"report results")
+
+        for tbl_reporter in self.table_reporters:
+            try:
+                tbl_reporter.upload(self)
+            except Exception as e:
+                self.error(e, "issue in {tbl_reporter}")
+
+        for plt_reporter in self.plot_reporters:
+            try:
+                plt_reporter.upload(self)
+            except Exception as e:
+                self.error(e, "issue in {plt_reporter}")
+
+        if self.show_plots:
+            self.info(f"showing plots {len(self.stored_plots)}")
+            for figkey, fig in self.stored_plots.items():
+                self.info(f"showing {figkey}")
+                try:
+                    fig.show()
+                except Exception as e:
+                    self.error(e, f"issue showing {figkey}")
+
+        self._uploaded = True
+
+    @property
+    def dataframe(self):
+        # TODO: join with analysis dataframe
+        return self.system.dataframe
+
+    # Plotting & Report Methods:
+
+
+#     @property
+#     def _report_path(self):
+#         """Add some name options that work into ClientInfoMixin"""
+#
+#         if (
+#             self.namepath_mode == "both"
+#             and self.mode == "iterator"
+#             and isinstance(self.component_iterator, Component)
+#         ):
+#             return os.path.join(
+#                 self.namepath_root,
+#                 f"{self.name}",
+#                 f"{self.component_iterator.name}",
+#             )
+#         elif (
+#             self.namepath_mode == "iterator"
+#             and self.mode == "iterator"
+#             and isinstance(self.component_iterator, Component)
+#         ):
+#             return os.path.join(
+#                 self.namepath_root, f"{self.component_iterator.name}"
+#             )
+#         else:
+#             if self.name != "default":
+#                 return os.path.join(
+#                     self.namepath_root, f"{self.classname.lower()}_{self.name}"
+#                 )
+#             return os.path.join(self.namepath_root, f"{self.classname.lower()}")
+
+# @property
+# def component_iterator(self) -> ComponentIterator:
+#     """Override me!"""
+#     return self.iterator
+
+# def post_process(self):
+#     """override me!"""
+#     pass
+#
+#     def reset_analysis(self):
+#         self.reset_data()
+#         self._solved = False
+#         self.run_id = None
+
+#     def gsync_results(self, filename="Analysis", meta_tags=None):
+#         """Syncs All Variable Tables To The Cloud"""
+#         with self.drive.context(
+#             filepath_root=self.local_sync_path, sync_root=self.cloud_sync_path
+#         ) as gdrive:
+#             with self.drive.rate_limit_manager(
+#                 self.gsync_results, 6, filename=filename, meta_tags=meta_tags
+#             ):
+#                 old_sleep = gdrive._sleep_time
+#                 gdrive.reset_sleep_time(max(old_sleep, 1.0))
+#
+#                 gpath = gdrive.sync_path(self.local_sync_path)
+#
+#                 self.debug(f"saving as gsheets {gpath}")
+#                 parent_id = gdrive.get_gpath_id(gpath)
+#                 # TODO: delete old file if exists
+#
+#                 gdrive.sleep(12 * random.random())
+#
+#                 gdrive.cache_directory(parent_id)
+#                 gdrive.sleep()
+#
+#                 # Remove items with same name in parent dir
+#                 parent = gdrive.item_nodes[parent_id]
+#                 parent.remove_contents_with_title(filename)
+#
+#                 df = self.joined_dataframe
+#
+#                 # Make the new sheet
+#                 sht = gdrive.gsheets.create(filename, folder=parent_id)
+#                 gdrive.sleep(2 * (1 + gdrive.time_fuzz * random.random()))
+#
+#                 wk = sht.add_worksheet(filename)
+#                 gdrive.sleep(2 * (1 + gdrive.time_fuzz * random.random()))
+#
+#                 wk.rows = df.shape[0]
+#                 gdrive.sleep(2 * (1 + gdrive.time_fuzz * random.random()))
+#
+#                 wk.set_dataframe(df, start="A1", fit=True)
+#                 gdrive.sleep(2 * (1 + gdrive.time_fuzz * random.random()))
+#
+#                 for df_result in self.variable_tables:
+#                     df = df_result["df"]
+#                     conf = df_result["conf"]
+#
+#                     if meta_tags is not None and type(meta_tags) is dict:
+#                         for tag, value in meta_tags.items():
+#                             df[tag] = value
+#
+#                     gdrive.sleep(2 * (1 + gdrive.time_fuzz * random.random()))
+#                     wk = sht.add_worksheet(conf.displayname)
+#                     gdrive.sleep(2 * (1 + gdrive.time_fuzz * random.random()))
+#
+#                     wk.rows = df.shape[0]
+#                     gdrive.sleep(2 * (1 + gdrive.time_fuzz * random.random()))
+#
+#                     wk.set_dataframe(df, start="A1", fit=True)
+#                     gdrive.sleep(2 * (1 + gdrive.time_fuzz * random.random()))
+#
+#                 sht.del_worksheet(sht.sheet1)
+#                 gdrive.sleep(2 * (1 + gdrive.time_fuzz * random.random()))
+#
+#                 # TODO: add in dataframe dict with schema sheename: {dataframe,**other_args}
+#                 self.info(
+#                     "gsheet saved -> {}".format(os.path.join(gpath, filename))
+#                 )
+#
+#                 gdrive.reset_sleep_time(old_sleep)
+
+#     @property
+#     def columns(self):
+#         if self.solved:
+#             return list(self.joined_dataframe)
+#         else:
+#             return []
+#
+#     def plot(self, x, y, kind="line", **kwargs):
+#         """
+#         A wrapper for pandas dataframe.plot
+#         :param grid: set True if input is not False
+#         """
+#
+#         # TODO: Add a default x iterator for what is iterated in analysis!
+#
+#         if "grid" not in kwargs:
+#             kwargs["grid"] = True
+#
+#         if isinstance(y, (list, tuple)):
+#             old_y = set(y)
+#             y = list([yval for yval in y if yval in self.dataframe.columns])
+#             rmv_y = set.difference(old_y, set(y))
+#             if rmv_y:
+#                 self.warning(f"vars not found: {rmv_y}")
+#
+#         if self.solved and y:
+#             df = self.dataframe
+#             return df.plot(x=x, y=y, kind=kind, **kwargs)
+#         elif y:
+#             self.warning("not solved yet!")
+#         elif self.solved:
+#             self.warning("bad input!")

engforge/attr_dynamics.py

@@ -0,0 +1,222 @@
+from engforge.attributes import ATTR_BASE, AttributeInstance
+
+import attrs, attr, uuid
+
+
+# Instance & Attribute definition for integration vars
+# Solver minimizes residual by changing independents
+class IntegratorInstance(AttributeInstance):
+    """A decoupled signal instance to perform operations on a system instance"""
+
+    system: "System"
+
+    # compiled info
+    var_ref: "Ref"
+    rate_ref: "Ref"
+
+    __slots__ = ["system", "solver", "var_ref", "rate_ref"]
+
+    def __init__(self, solver: "Time", system: "System") -> None:
+        self.class_attr = self.solver = solver
+        self.system = system
+        self.compile()
+
+    def compile(self):
+        self.var_ref = self.system.locate_ref(self.solver.var)
+        self.rate_ref = self.system.locate_ref(self.solver.rate)
+        self.system.debug(f"integrating {self.var_ref} with {self.rate_ref}")
+
+    def as_ref_dict(self):
+        return {"rate": self.rate_ref, "var": self.var_ref}
+
+    @property
+    def rates(self):
+        return {self.name: self.class_attr.rate}
+
+    @property
+    def integrated(self):
+        return {self.name: self.class_attr.var}
+
+    @property
+    def var(self):
+        return self.class_attr.var
+
+    @property
+    def rate(self):
+        return self.class_attr.rate
+
+    @property
+    def current_rate(self):
+        return self.rate_ref.value(self.system, self.system.last_context)
+
+    @property
+    def constraint_refs(self):
+        if self.solver.slvtype in ["eq", "ineq"]:
+            return self.const_f
+        return None
+
+    @property
+    def constraints(self):
+        if hasattr(self, "_constraints"):
+            return self._constraints
+
+        return self.solver.constraints
+
+        # return [{'type':self.slvtype,'var':self.solver.lhs,'value':self.const_f}]
+        # if self.solver.slvtype in ['var','obj']:
+        #    return self.solver.constraints
+        # else:
+        # just me
+
+    @property
+    def slvtype(self):
+        return self.solver.slvtype
+
+    @property
+    def combos(self):
+        return self.solver.combos
+
+    @property
+    def normalize(self):
+        return self.solver.normalize
+
+    @property
+    def active(self):
+        if hasattr(self, "_active"):
+            return self._active
+
+
+# TODO: depriciate modes and update for dynamicmixin strategies
+# TODO: add Time.add_profile(parm, time:parameter_values, combos,active) to add a transient profile to be run on the system that is selectable by the user
+
+
+class Time(ATTR_BASE):
+    """Transient is a base class for integrators over time"""
+
+    mode: str
+    var: str
+    rate: str
+    constraints: list
+    allow_constraint_override: bool = True
+    instance_class = IntegratorInstance
+
+    @classmethod
+    def integrate(
+        cls,
+        var: str,
+        rate: "system_property",
+        mode: str = "euler",
+        active=True,
+        combos="default",
+    ):
+        """Defines an ODE like integrator that will be integrated over time with the defined integration rule.
+
+        Input should be of strings to look up the particular property or field
+        """
+        # Create A New Signals Class
+        new_name = f"TRANSIENT_{mode}_{var}_{rate}".replace(".", "_")
+        # new_name = new_name
+        new_dict = dict(
+            mode=mode,
+            name=new_name,
+            var=var,
+            rate=rate,
+            active=active,
+            constraints=[],  # TODO: parse kwargs for limits
+            combos=cls.process_combos(combos, add_combos=f"time,{var}"),
+        )
+        return cls._setup_cls(new_name, new_dict)
+
+    # make define the same as integrate
+    # @classmethod
+    # def subcls_compile(cls,**kwargs):
+    #     cls.define = cls.integrate
+
+    @classmethod
+    def class_validate(cls, instance, **kwargs):
+        from engforge.properties import system_property
+        from engforge.solver import SolveableMixin
+
+        system = cls.config_cls
+        assert issubclass(system, SolveableMixin), f"must be a solveable system"
+
+        var_type = instance.locate(cls.var)
+        if var_type is None:
+            raise Exception(f"var not found: {cls.var}")
+        assert isinstance(
+            var_type, attrs.Attribute
+        ), f"bad var {cls.var} not attribute: {var_type}"
+        assert var_type.type in (
+            int,
+            float,
+        ), f"bad var {cls.var} not numeric"
+
+        driv_type = instance.locate(cls.rate)
+        if driv_type is None:
+            raise Exception(f"rate not found: {cls.rate}")
+        assert isinstance(
+            driv_type, (system_property, attrs.Attribute)
+        ), f"bad rate {cls.rate} type: {driv_type}"
+        if isinstance(driv_type, system_property):
+            assert driv_type.return_type in (
+                int,
+                float,
+            ), f"bad var {cls.rate} not numeric"
+
+        # else: attributes are not checked, youre in command
+
+    @classmethod
+    def add_var_constraint(cls, value, kind="min", **kwargs):
+        """adds a `type` constraint to the solver. If value is numeric it is used as a bound with `scipy` optimize.
+
+        :param type: str, must be either min or max with var value comparison, or with a function additionally eq,ineq (same as max(0)) can be used
+        :value: either a numeric (int,float), or a function, f(system)
+        """
+        assert cls is not Time, f"must set constraint on Time Attribute"
+        # assert not cls.constraint_exists(type=kind,var=var), f"constraint already exists!"
+        assert isinstance(value, (int, float)) or callable(
+            value
+        ), f"only int,float or callables allow. Callables must take system as argument"
+
+        var = cls.var
+        assert var is not None, "must provide var on non-var solvers"
+        assert kind in ("min", "max")
+        combo_dflt = "default,lim"
+        cmbs = kwargs.get("combos", "")
+        combos = cls.process_combos(cmbs, combo_dflt, combo_dflt)
+        if isinstance(combos, str):
+            combos = combos.split(",")
+        active = kwargs.get("active", True)
+        const = {
+            "type": kind,
+            "value": value,
+            "var": var,
+            "active": active,
+            "combos": combos,
+            "combo_var": cls.name,
+        }
+        # print(const,cls.__dict__)
+
+        cinx = cls.constraint_exists(type=kind, var=var)
+        inix = cinx is not None
+        if cls.allow_constraint_override and inix:
+            # print(f'replacing constraint {cinx} with {kind} {value} {var}')
+            constraint = cls.constraints[cinx]
+            constraint.update(const)
+        elif not cls.allow_constraint_override and inix:
+            cnx = cls.constraints[cinx]
+            raise Exception(f"constraint already exists! {cnx}")
+        else:
+            cls.constraints.append(const)
+
+    @classmethod
+    def constraint_exists(cls, **kw):
+        """check constraints on the system, return its index position if found, else None."""
+        for i, c in enumerate(cls.constraints):
+            if all([c[k] == v for k, v in kw.items()]):
+                return i
+        return None
+
+
+# Support Previous API
+TRANSIENT = Time