engforge 0.3.0__py3-none-any.whl

engforge/attributes.py

@@ -0,0 +1,326 @@
+"""Defines a customizeable attrs attribute that is handled in configuration,
+
+on init an instance of `Instance` type for any ATTR_BASE subclass is created"""
+
+import attrs, attr, uuid
+from engforge.logging import LoggingMixin, log
+
+
+class ATTRLog(LoggingMixin):
+    pass
+
+
+log = ATTRLog()
+
+
+DEFAULT_COMBO = "default"
+
+
+class AttributeInstance:
+    class_attr: "ATTR_BASE"
+    system: "System"
+    classname: str = "attribute"  # for ref compatability
+    backref: "ATTR_BASE"
+
+    # TODO: universal slots method
+    # __slots__ = ["system", "class_attr"]
+
+    def __init__(self, class_attr: "CLASS_ATTR", system: "System", **kwargs) -> None:
+        self.class_attr = class_attr
+        self.system = system
+        self.compile(**kwargs)
+
+    def compile(self, **kwargs):
+        # raise NotImplementedError("Override Me!")
+        pass
+
+    def as_ref_dict(self) -> dict:
+        log.info(f"pass - as ref {self}")
+        return None
+
+    def get_alias(self, path):
+        return path.split(".")[-1]
+
+    def is_active(self, value=False) -> bool:
+        mthd = "dflt"
+        if hasattr(self, "_active"):
+            mthd = "instance"
+            value = self._active
+
+        elif hasattr(self.class_attr, "active"):
+            mthd = "class"
+            value = self.class_attr.active
+
+        # print(f'{self}| {mthd} is_active: {value}')
+        # the default
+        return value
+
+    @property
+    def combos(self):
+        return self.class_attr.combos
+
+    @property
+    def active(self):
+        return self.class_attr.active
+
+
+# TODO: add a concept of queries of ATTR_BASE subclasses, where multiple types may be selected or filtered, with individual arguments.
+class ATTR_BASE(attrs.Attribute):
+    """A base class that handles initalization in the attrs meta class scheme by ultimately createing an Instance"""
+
+    name: str
+    config_cls: "System"
+    attr_prefix = "ATTR"
+    instance_class: AttributeInstance = AttributeInstance  # Define me
+    default_options: dict
+    template_class = True
+
+    # TODO: add generic selection & activation of attributes
+    active: bool
+    combos: list
+
+    none_ok = False
+
+    # Activation & Combo Selection Functionality
+    @classmethod
+    def process_combos(cls, combos, default=None, add_combos=None):
+        if isinstance(combos, str):
+            if "*" in combos:
+                raise KeyError("wildcard (*) not allowed in combos!")
+            out = combos.split(",")
+        elif isinstance(combos, list):
+            if any(["*" in c for c in combos]):
+                raise KeyError("wildcard (*) not allowed in combos!")
+            out = combos
+        else:
+            out = []
+
+        if add_combos is not None:
+            out += cls.process_combos(add_combos, default=default)
+
+        if out:
+            return out
+        if default:
+            return default
+        return ["default"]
+
+    # Initialization
+    @classmethod
+    def configure_for_system(cls, name, config_class, cb=None, **kwargs):
+        """add the config class, and perform checks with `class_validate)
+        :returns: [optional] a dictionary of options to be used in the make_attribute method
+        """
+        log.debug(f"{cls.__name__} is being configured for {cls.attr_prefix}")
+        cls.name = name
+        cls.config_cls = config_class
+
+        if isinstance(cls.instance_class, ATTR_BASE) and not hasattr(
+            cls.instance_class, "backref"
+        ):
+            # get parent class
+            refs = [cls, ATTR_BASE]
+            mro_group = cls.mro()
+            mro_group = mro_group[: mro_group.index(ATTR_BASE)]
+            cans = [v for v in mro_group if v not in refs]
+            last = cans[-1]
+            # if not hasattr(cls,'instance_class') or not cls.instance_class:
+            #     log.info(f'no instance class! {cls}')
+            cls.instance_class.backref = last
+        else:
+            pass
+            # print(f'backref exists {cls.instance_class.backref} {cls}')
+
+        if cb is not None:
+            cb(cls, config_class, **kwargs)
+
+        return {}  # OVERWRITE ME "custom_options":False
+
+    @classmethod
+    def create_instance(cls, instance: "Configuration") -> AttributeInstance:
+        """Create an instance of the instance_class"""
+        if cls.instance_class is None:
+            raise Exception(
+                f"Instance Class Hasnt Been Defined For `{cls}.instance_class`"
+            )
+        if not hasattr(cls, "config_cls"):
+            raise Exception(f"`config_cls` hasnt been defined for `{cls}`")
+
+        cls.class_validate(instance=instance)
+        return cls.instance_class(cls, instance)
+
+    # Override Me:
+    @classmethod
+    def configure_instance(cls, instance, attribute, value):
+        """validates the instance given attr's init routine"""
+        pass
+
+    @classmethod
+    def class_validate(cls, instance, **kwargs):
+        """validates onetime A method to validate the kwargs passed to the define method"""
+        pass
+
+    @classmethod
+    def define_validate(cls, **kwargs):
+        """A method to validate the kwargs passed to the define method"""
+        pass
+
+    # Interafce & Utility
+    @classmethod
+    def define(cls, **kwargs):
+        """taking a component or system class as possible input valid input is later validated as an instance of that class or subclass"""
+        assert (
+            not cls.template_class
+        ), f"{cls} is not template class and cannot defined anything, ie anything that has been created as a function of `define` cannot be defined"
+
+        cls.define_validate(**kwargs)
+
+        # Create A New Signals Class
+        kw_pairs = [f"{k}_{v}" for k, v in kwargs.items()]
+        new_name = f"{cls.attr_prefix}_{('_'.join(kw_pairs))}".replace(".", "_")
+        # define the class dictionary
+        new_dict = dict(name=new_name)
+        new_slot = cls._setup_cls(new_name, new_dict, **kwargs)
+        return new_slot
+
+    @classmethod
+    def _setup_cls(cls, name, new_dict, **kwargs):
+        # randomize name for specifics reasons
+        uid = str(uuid.uuid4())
+        # base info
+        name = name + "_" + uid.replace("-", "")[0:16]
+        new_dict["uuid"] = uid
+        new_dict["default_options"] = cls.default_options.copy()
+        new_dict["template_class"] = False
+        new_dict["name"] = name
+
+        # create a new type of attribute
+        new_slot = type(name, (cls,), new_dict)
+        new_slot.default_options["default"] = new_slot.make_factory()
+        new_slot.default_options["validator"] = new_slot.configure_instance
+        log.debug(
+            f"defined {name}|{new_slot} with {kwargs}| {new_slot.default_options}"
+        )
+        return new_slot
+
+    @classmethod
+    def make_factory(cls, **kwargs):
+        # print(f"{cls} making factory with: {kwargs}")
+        return attrs.Factory(cls.create_instance, takes_self=True)
+
+    @classmethod
+    def make_attribute(cls, name, comp_class, **kwargs):
+        """makes an attrs.Attribute for the class"""
+        cust_options = cls.configure_for_system(name, comp_class, **kwargs)
+        # make copy for new instance
+        opts = cls.default_options.copy()
+        # update with custom kwargs
+        if isinstance(cust_options, dict):
+            opts.update(cust_options)
+        # input has the final override
+        opts.update(kwargs)
+        # The core functionality
+        opts.update(name=name, type=cls)
+
+        # Handle the default and validator, if not overridden
+        if "default" not in kwargs:
+            opts["default"] = cls.make_factory()
+        if "validator" not in kwargs:
+            opts["validator"] = cls.configure_instance
+
+        return attrs.Attribute(**opts)
+
+    # Structural Orchestration Through Subclassing
+    @classmethod
+    def collect_cls(cls, system) -> dict:
+        """collects all the attributes for a system"""
+        if not isinstance(system, type):
+            system = system.__class__
+        return {k: at.type for k, at in system._get_init_attrs_data(cls).items()}
+
+    @classmethod
+    def collect_attr_inst(cls, system, handle_inst=True) -> dict:
+        """collects all the attribute instances for a system"""
+        cattr = cls.collect_cls(system)
+        out = {}
+        for k, v in cattr.items():
+            inst = getattr(system, k)
+            if (inst is None and getattr(cls.instance_class, "none_ok", False)) or (
+                cls.instance_class is not None
+                and not isinstance(inst, cls.instance_class)
+            ):
+                log.warning(
+                    f"Attribute {k}|{inst} is not an instance of {cls.instance_class} in {system}"
+                )
+                continue
+
+            if inst and handle_inst:
+                inst = cls.handle_instance(inst)
+
+            if inst is not None:
+                out[k] = inst
+        return out
+
+    @staticmethod
+    def unpack_atrs(d, pre="", conv=None):
+        if not conv:
+            conv = lambda v: v
+        if isinstance(d, dict):
+            for k, v in d.items():
+                if not isinstance(v, dict):
+                    yield k, pre, conv(v)
+                elif v:
+                    if pre and not pre.endswith("."):
+                        ppre = pre + "."
+                    ck = f"{ppre}{k}"
+                    for kii, ki, vi in ATTR_BASE.unpack_atrs(v, ck):
+                        yield kii, ki, conv(vi)
+                else:
+                    if pre and not pre.endswith("."):
+                        ppre = pre + "."
+                    ck = f"{ppre}{k}"
+                    yield "", ck, v
+        return d
+
+    @classmethod
+    def handle_instance(cls, canidate):
+        """handles the instance, override as you wish"""
+        # print('handle_instance',cls,canidate,cls.instance_class)
+
+        if isinstance(canidate, cls.instance_class):
+            o = canidate.as_ref_dict()
+            return o
+        return canidate  # live and let live
+
+    @classmethod
+    def subclasses(cls, out=None):
+        """return all subclasses of components, including their subclasses
+        :param out: out is to pass when the middle of a recursive operation, do not use it!
+        """
+
+        # init the set by default
+        if out is None:
+            out = set()
+
+        for cls in cls.__subclasses__():
+            if not cls.template_class:
+                continue
+            out.add(cls)
+            cls.subclasses(out)
+
+        return out
+
+
+ATTR_BASE.default_options = dict(
+    # validator=ATTR_BASE.configure_instance,
+    repr=False,
+    cmp=None,
+    hash=None,
+    init=False,  # change this to allow for init input
+    metadata=None,
+    converter=None,
+    kw_only=True,
+    eq=None,
+    order=None,
+    on_setattr=None,
+    inherited=False,
+)

engforge/common.py

@@ -0,0 +1,76 @@
+"""A set of common values and functions that are globaly available."""
+
+import sys
+import functools
+
+# Common Modules
+from engforge.configuration import *
+from engforge.logging import LoggingMixin
+from urllib.request import urlopen
+
+import numpy
+
+
+class ForgeLog(LoggingMixin):
+    pass
+
+
+log = ForgeLog()
+log.info("Starting engforge Enviornment")
+
+
+class inst_vectorize(numpy.vectorize):
+    def __get__(self, obj, objtype):
+        return functools.partial(self.__call__, obj)
+
+
+def chunks(lst, n):
+    """Yield successive n-sized chunks from lst."""
+    for i in range(0, len(lst), n):
+        yield lst[i : i + n]
+
+
+def is_ec2_instance():
+    """Check if an instance is running on AWS."""
+    result = False
+    meta = "http://169.254.169.254/latest/meta-data/public-ipv4"
+    try:
+        result = urlopen(meta, timeout=5.0).status == 200
+        return True
+    except:
+        return False
+    return False
+
+
+def get_size(obj, seen=None):
+    """Recursively finds size of objects"""
+    size = sys.getsizeof(obj)
+    if seen is None:
+        seen = set()
+    obj_id = id(obj)
+    if obj_id in seen:
+        return 0
+    # Important mark as seen *before* entering recursion to gracefully handle
+    # self-referential objects
+    seen.add(obj_id)
+    if isinstance(obj, dict):
+        size += sum([get_size(v, seen) for v in obj.values()])
+        size += sum([get_size(k, seen) for k in obj.keys()])
+    elif hasattr(obj, "__dict__"):
+        size += get_size(obj.__dict__, seen)
+    elif hasattr(obj, "__iter__") and not isinstance(obj, (str, bytes, bytearray)):
+        size += sum([get_size(i, seen) for i in obj])
+    return size
+
+
+# Constants
+g = gravity = 9.80665  # m/s2
+G_grav_constant = 6.67430e-11  # m3/kgs
+speed_of_light = 299792458  # m/s
+u_planck = 6.62607015e-34  # Js
+R_univ_gas = 8.314462618  # J/molkg
+mass_electron = 9.1093837015e-31  # kg
+mass_proton = 1.67262192369e-27
+mass_neutron = 1.67492749804e-27
+r_electron = 2.8179403262e-15
+Kboltzman = 1.380649e-23  # J⋅K−1

engforge/component_collections.py

@@ -0,0 +1,276 @@
+"""define a collection of components that will propigate to its parents dataframe
+
+When `wide` is set each component's references are reported to the system's table, otherwise only one component's references are reported, however the system will iterate over the components by calling `system.iterable_components`
+
+Define a Iterable Component slot in a system by calling `Slot.define_iterable(...,wide=True/False)`
+
+CostModel isonly supported in wide mode at this time.
+
+Types:
+1. ComponentList, ordered by index
+2. ComponentDict, ordered by key
+3. ComponentGraph,  ?#TODO:
+"""
+
+from collections import UserDict, UserList
+from engforge.components import Component
+from engforge.attr_slots import Slot
+from engforge.configuration import forge
+from engforge.typing import *
+from engforge.system_reference import Ref, system_property
+from engforge.properties import *
+
+
+import attrs
+
+
+def check_comp_type(instance, attr, value):
+    """ensures the input component type is a Component"""
+    from engforge.eng.costs import CostModel
+
+    if not instance.wide and isinstance(value, type) and issubclass(value, CostModel):
+        raise TypeError(f"Cost Mixin Not Supported As Iter Type! {value}")
+
+    if isinstance(value, type) and issubclass(value, Component):
+        return
+
+    raise TypeError(f"Not A Component Class! {value}")
+
+
+class iter_tkn:
+    """ambigious type to keep track of iterable position form system reference"""
+
+    pass
+
+
+@forge
+class ComponentIter(Component):
+    """Iterable components are designed to eval a large selection of components either one-by-one or all at once at the system level depending on if `wide` property is set."""
+
+    _ref_cache: dict = None
+    _item_refs: dict = None
+
+    wide: bool = True
+
+    # what holds the components
+    data: iter
+
+    # current item keu, non table type, this triggers `anything_changed` in `system._iterate_component()`
+    current_item: iter_tkn = attr.ib(factory=lambda: None, hash=False, eq=False)
+    _first_item_key: iter_tkn
+
+    @property
+    def current(self):
+        """returns all data in wide format and the active key in _current_item"""
+        if self.wide:
+            return self.data
+        else:
+            if self.current_item is None:
+                if not hasattr(self, "_first_item_key"):
+                    next(self._item_gen())
+                return self.data[self._first_item_key]
+            return self.data[self.current_item]
+
+    def _item_gen(self):
+        for key, item in self.data.items():
+            if not hasattr(self, "_first_item_key"):
+                self._first_item_key = key
+            yield key, item
+
+    def __setitem__(self, key, value):
+        assert isinstance(
+            value, self.component_type
+        ), f"{value} is not of type: {self.component_type}"
+        super().__setitem__(key, value)
+        self.reset()
+
+    def reset(self):
+        # reset reference cache
+        self._prv_internal_references = None
+        self._item_refs = None
+        self.current_item = None
+
+    def _item_key(self, itkey, item):
+        """override this to customize data access to self.data or other container name"""
+        return itkey
+
+    # TODO: way to update internal references in problem, do on update()?
+    @property
+    def _internal_references(self) -> dict:
+        """considers wide format to return active references"""
+        if self.wide:
+            return self._prv_internal_references
+        else:
+            if self.current_item is None:
+                return self._item_refs[self._first_item_key]
+            return self._item_refs[self.current_item]
+
+    def comp_references(self, **kw):
+        """Returns this components global references"""
+        out = {}
+        out["attributes"] = at = {}
+        out["properties"] = pr = {}
+
+        for key in self.system_properties_classdef():
+            pr[key] = Ref(self, key, True, False)
+
+        for key in self.input_fields():
+            at[key] = Ref(self, key, False, True)
+
+        return out
+
+    def internal_references(self, recache=False, numeric_only=False):
+        """lists the this_name.comp_key.<attr/prop key>: Ref format to override data_dict"""
+
+        if (
+            recache == False
+            and hasattr(self, "_prv_internal_references")
+            and self._prv_internal_references
+        ):
+            return self._internal_references
+
+        keeprefcopy = lambda d: {k: {**c} for k, c in d.items()}
+
+        out = keeprefcopy(self.comp_references())
+        at = out["attributes"]  # = at = {}
+        pr = out["properties"]  # = pr = {}
+        _item_refs = {}
+
+        for itkey, item in self._item_gen():
+            it_base_key = self._item_key(itkey, item)
+
+            _item_refs[itkey] = ir = keeprefcopy(self.comp_references())
+            atr = ir["attributes"]  # = atr = {}
+            prr = ir["properties"]  # = prr = {}
+
+            # set property refs
+            for key in item.system_properties_classdef():
+                k = f"{it_base_key}.{key}"
+                rc = Ref(item, key, True, False)
+                pr[k] = rc
+                prr[key] = rc
+
+            # set attr refs
+            if numeric_only:
+                for key in item.numeric_fields():
+                    k = f"{it_base_key}.{key}"
+                    ri = Ref(item, key, False, True)
+                    at[k] = ri
+                    atr[key] = ri
+
+            else:
+                for key in item.input_fields():
+                    k = f"{it_base_key}.{key}"
+                    ri = Ref(item, key, False, True)
+                    at[k] = ri
+                    atr[key] = ri
+
+        # cache the references
+        self._prv_internal_references = out
+        self._item_refs = _item_refs
+        return self._internal_references
+
+    def __hash__(self):
+        return hash(id(self))
+
+
+@forge
+class ComponentDict(ComponentIter, UserDict):
+    """Stores components by name, and allows tabulation of them"""
+
+    component_type: type = attrs.field(validator=check_comp_type)
+
+    # tabulate_depth:int = attrs.field(default=1) #TODO: impement this
+
+    _ref_cache: dict = None
+
+    # Dict Setup
+    def __on_init__(self):
+        UserDict.__init__(self)
+
+    def __str__(self):
+        return f"{self.__class__.__name__}[{len(self.data)}]"
+
+    def __repr__(self) -> str:
+        return str(self)
+
+
+@forge
+class ComponentIterator(ComponentIter, UserList):
+    """Stores components by name, and allows tabulation of them"""
+
+    component_type: type = attrs.field(validator=check_comp_type)
+
+    # Dict Setup
+    def __on_init__(self):
+        UserList.__init__(self)
+
+    def _item_gen(self):
+        for i, item in enumerate(self.data):
+            if not hasattr(self, "_first_item_key"):
+                self._first_item_key = i
+            yield i, item
+
+    def _item_key(self, itkey, item):
+        return f"{self.component_type.__name__.lower()}.{itkey}"
+
+    # def __setitem__(self, key, value):
+    #     assert isinstance(value,self.component_type)
+    #     super().__setitem__(key, value)
+    #     #reset reference cache
+    #     self._ref_cache = None
+
+
+#     #Tabulation Override
+#     @property
+#     def internal_references(self):
+#         """lists the this_name.comp_key.<attr/prop key>: Ref format to override data_dict"""
+#
+#         if self._ref_cache:
+#             return self._ref_cache
+#
+#         out = {}
+#         out["attributes"] = at = {}
+#         out["properties"] = pr = {}
+#
+#         for itkey,item in self._item_gen():
+#             it_base_key = f'{itkey}'
+#
+#             for key in item.system_properties_classdef():
+#                 k = f'{it_base_key}.{key}'
+#                 pr[k] = Ref(item, key)
+#
+#             for key in item.input_fields():
+#                 k = f'{it_base_key}.{key}'
+#                 at[k] = Ref(item, key, False)
+#
+#         #cache the references
+#         self._ref_cache = out
+#         return out
+
+#     #Tabulation Override
+#     @property
+#     def internal_references(self):
+#         """lists the this_name.comp_key.<attr/prop key>: Ref format to override data_dict"""
+#
+#         if self._ref_cache:
+#             return self._ref_cache
+#
+#         out = {}
+#         out["attributes"] = at = {}
+#         out["properties"] = pr = {}
+#
+#         for it,item in self._item_gen():
+#             it_base_key = f'{self.component_type.__name__.lower()}.{it}'
+#
+#             for key in item.system_properties_classdef():
+#                 k = f'{it_base_key}.{key}'
+#                 pr[k] = Ref(item, key)
+#
+#             for key in item.input_fields():
+#                 k = f'{it_base_key}.{key}'
+#                 at[k] = Ref(item, key, False)
+#
+#         #cache the references
+#         self._ref_cache = out
+#         return out