def __init__(self, agent, mta): self.messages = [] self.agent = weakref_ref(agent) self.mta = weakref_ref(mta) self.events = agent.getEvents() for event in self.events: mta.registerMailingList(self, event)
def __setstate__(self, state): self.byObject = dict( (id(obj), key) for key, obj in state['bySymbol'] ) self.bySymbol = dict( (key, weakref_ref(obj)) for key, obj in state['bySymbol'] ) self.aliases = dict( (key, weakref_ref(obj)) for key, obj in state['aliases'] )
def __init__(self, method, cb = None): from util.introspect import funcinfo assert hasattr(method, 'im_self'), 'no im_self: %s' % funcinfo(method) self.object = weakref_ref(method.im_self, cb) self.func = weakref_ref(method.im_func) self.cls = weakref_ref(method.im_class)
def set_value(self, vals): """Set the port attributes on this arc""" # the following allows m.a = Arc(directed=True); m.a = (m.p, m.q) # and m.a will be directed d = self._directed if self._directed is not None else \ self.parent_component()._init_directed vals = _iterable_to_dict(vals, d, self.name) source = vals.pop("source", None) destination = vals.pop("destination", None) ports = vals.pop("ports", None) directed = vals.pop("directed", None) if len(vals): raise ValueError( "set_value passed unrecognized keywords in val:\n\t" + "\n\t".join("%s = %s" % (k, v) for k, v in iteritems(vals))) if directed is not None: if source is None and destination is None: if directed and ports is not None: # implicitly directed ports tuple, transfer to src and dest try: source, destination = ports ports = None except: raise ValueError( "Failed to unpack 'ports' argument of arc '%s'. " "Argument must be a 2-member tuple or list." % self.name) elif not directed: # throw an error if they gave an inconsistent directed value raise ValueError( "Passed False value for 'directed' for arc '%s', but " "specified source or destination." % self.name) self._validate_ports(source, destination, ports) if self.ports is not None: # we are reassigning this arc's values, clean up port lists weakref_self = weakref_ref(self) for port in self.ports: port._arcs.remove(weakref_self) if self._directed: self.source._dests.remove(weakref_self) self.destination._sources.remove(weakref_self) self._ports = tuple(ports) if ports is not None \ else (source, destination) self._directed = source is not None weakref_self = weakref_ref(self) for port in self._ports: port._arcs.append(weakref_self) if self._directed: source._dests.append(weakref_self) destination._sources.append(weakref_self)
def __init__(self, obj, method, cb = None): self.object = weakref_ref(obj, cb) self.func = weakref_ref(method) try: unbound_cbs = obj._unbound_cbs except AttributeError: obj._unbound_cbs = unbound_cbs = {} unbound_cbs[self] = method
def __init__(self, project, name, mta=None, application=None): if not mta: mta = project.mta() Agent.__init__(self, name, mta) self.project = weakref_ref(project) if not application: application = project.application() self.application = weakref_ref(application) if project is not self: self.score_weight = 1.0 self.register()
def __setstate__(self, state): self._metadata = state['_metadata'] self._entry = {} for name, data in iteritems(state['_entry']): tmp = self._entry[name] = {} for obj, entry in data: tmp[ id(obj) ] = ( weakref_ref(obj), entry )
def __setstate__(self, state): """ This method must be defined to support unpickling because this class owns weakrefs for '_component'. """ # # FIXME: We shouldn't have to check for weakref.ref here, but if # we don't the model cloning appears to fail (in the Benders # example) # if state['_component'] is not None and \ type(state['_component']) is not weakref_ref: state['_component'] = weakref_ref(state['_component']) # # Note: our model for setstate is for derived classes to modify # the state dictionary as control passes up the inheritance # hierarchy (using super() calls). All assignment of state -> # object attributes is handled at the last class before 'object' # (which may -- or may not (thanks to MRO) -- be here. # _base = super(ComponentData,self) if hasattr(_base, '__setstate__'): return _base.__setstate__(state) else: for key, val in iteritems(state): # Note: per the Python data model docs, we explicitly # set the attribute using object.__setattr__() instead # of setting self.__dict__[key] = val. object.__setattr__(self, key, val)
def __init__(self, domain=Reals, component=None): # # These lines represent in-lining of the # following constructors: # - _VarData # - ComponentData # - NumericValue self._component = weakref_ref(component) if (component is not None) \ else None self._value = None # # The type of the lower and upper bound attributes can either # be atomic numeric types in Python, expressions, etc. # Basically, they can be anything that passes an "is_fixed" test. # self._lb = None self._ub = None self._domain = None self.fixed = False self.stale = True # don't call the property setter here because # the SimplVar constructor will fail if hasattr(domain, 'bounds'): self._domain = domain else: raise ValueError( "%s is not a valid domain. Variable domains must be an " "instance of one of %s an object that declares a method " "for bounds (like a Pyomo Set). Examples: NonNegativeReals, " "Integers, Binary" % (domain, (RealSet, IntegerSet, BooleanSet)))
def getSymbol(self, obj, labeler=None, *args): """ Return the symbol for an object. If it has not already been cached in the symbol map, then create it. """ obj_id = id(obj) if obj_id in self.byObject: return self.byObject[obj_id] # # Create a new symbol, performing an error check if it is a duplicate # if labeler is None: raise RuntimeError("Object %s is not in the symbol map. " "Cannot create a new symbol without " "a labeler." % obj.cname(True)) symb = labeler(obj) if symb in self.bySymbol: if self.bySymbol[symb]() is not obj: raise RuntimeError( "Duplicate symbol '%s' already associated with " "component '%s' (conflicting component: '%s')" % (symb, self.bySymbol[symb]().cname(True), obj.cname(True)) ) self.bySymbol[symb] = weakref_ref(obj) self.byObject[obj_id] = symb return symb
def construct(self, data=None): """Construct this component.""" if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover try: name = str(self.cname(True)) except: # Some Var components don't have a name yet, so just use the type name = type(self) if logger.isEnabledFor(logging.DEBUG): logger.debug( "Constructing Variable, name=%s, from data=%s" % (name, str(data))) if self._constructed: return self._constructed=True # # Construct _VarData objects for all index values # if not self.is_indexed(): self._data[None] = self self._initialize_members([None]) elif self._dense: # This loop is optimized for speed with pypy. # Calling dict.update((...) for ...) is roughly # 30% slower self_weakref = weakref_ref(self) for ndx in self._index: cdata = _GeneralVarData(Reals, component=None) cdata._component = self_weakref self._data[ndx] = cdata self._initialize_members(self._index)
def __setitem__(self, i, item): if isinstance(item, self._interface_datatype): if item._component is None: item._component = weakref_ref(self) if hasattr(self, "_active"): self._active |= getattr(item, '_active', True) # release the current component (assuming we don't get # an index error) # * see __delitem__ for explanation self._data[i]._component = None self._data[i] = item return # see note about allowing components to live in more than # one container raise ValueError( "Invalid component object assignment to ComponentList " "%s at index %s. A parent component has already been " "assigned the object: %s" % (self.cname(True), i, item.parent_component().cname(True))) # see note about implicit assignment and update raise TypeError( "ComponentList must be assigned objects " "of type %s. Invalid type for key %s: %s" % (self._interface_datatype.__name__, i, type(item)))
def __init__(self, process): type = process.stdout if type not in ('null', 'file'): raise ValueError('Invalid stdout type: %r' % type) SessionAgent.__init__(self, process.project().session, "stdout file") self.type = type self.process = weakref_ref(process)
def __getitem__(self, x): if isinstance(x,(tuple,list)): x = tuple(x) else: x = (x,) try: return self._children[x] except KeyError: Klass = self._value.__class__ if Klass in _ItemWrapper: WKlass = _ItemWrapper[Klass] else: _ItemWrapper[Klass] = WKlass = self.wKlassFactory(Klass) child = WKlass() for i in filter(lambda x,K=list(child.__dict__.keys()): x in K,list(child._attrMap.keys())): del child.__dict__[i] child.__dict__.update(dict( __propholder_parent__ = weakref_ref(self), __propholder_index__ = x[:-1]) ) self._children[x] = child return child
def getSymbol(self, obj, labeler=None, *args): """ Return the symbol for an object. If it has not already been cached in the symbol map, then create it. """ obj_id = id(obj) if obj_id in self.byObject: return self.byObject[obj_id] # # Create a new symbol, performing an error check if it is a duplicate # if labeler: symb = labeler(obj) elif self.default_labeler: symb = self.default_labeler(obj) else: symb = str(obj) if symb in self.bySymbol: if self.bySymbol[symb]() is not obj: raise RuntimeError( "Duplicate symbol '%s' already associated with " "component '%s' (conflicting component: '%s')" % (symb, self.bySymbol[symb]().name, obj.name) ) self.bySymbol[symb] = weakref_ref(obj) self.byObject[obj_id] = symb return symb
def __init__(self, application): self.application = weakref_ref(application) self.timestamp_format = '%(asctime)s: %(message)s' # Choose log levels if application.options.debug: stdout_level = INFO file_level = DEBUG elif application.options.verbose: stdout_level = WARNING file_level = INFO elif not application.options.quiet: stdout_level = ERROR file_level = WARNING else: stdout_level = ERROR file_level = INFO self.logger = getLogger() # fusil.log file self.filename = LOG_FILENAME self.file_handler = self.addFileHandler(self.filename, file_level) # Create stdout logger handler = StreamHandler(stdout) self.addHandler(handler, stdout_level)
def __setitem__(self, key, val): if isinstance(val, self._interface_datatype): if val._component is None: val._component = weakref_ref(self) self._active |= getattr(val, '_active', True) if key in self._data: # release the current component # * see __delitem__ for explanation self._data[key]._component = None self._data[key] = val return # see note about allowing components to live in more than # one container raise ValueError( "Invalid component object assignment to ComponentDict " "%s at key %s. A parent component has already been " "assigned the object: %s" % (self.cname(True), key, val.parent_component().cname(True))) # see note about implicit assignment and update raise TypeError( "ComponentDict must be assigned objects " "of type %s. Invalid type for key %s: %s" % (self._interface_datatype.__name__, key, type(val)))
def __init__(self, component=None): # # These lines represent in-lining of the # following constructors: # - ComponentData # - NumericValue self._component = weakref_ref(component) if (component is not None) \ else None
def addSymbols(self, obj_symbol_tuples): """ Add (object, symbol) tuples from an iterable object. This method assumes that symbol names will not conflict. """ tuples = list((obj, symb) for obj,symb in obj_symbol_tuples) self.byObject.update((id(obj_), symb_) for obj_,symb_ in tuples) self.bySymbol.update((symb_, weakref_ref(obj_)) for obj_,symb_ in tuples)
def __init__(self, component): # # ComponentData objects are typically *private* objects for # indexed / sparse indexed components. As such, the (derived) # class needs to make sure that the owning component is *always* # passed as the owner (and that owner is never None). Not validating # this assumption is significantly faster. # self._component = weakref_ref(component)
def getSubIStream(self): if hasattr(self, "_sub_istream"): stream = self._sub_istream() else: stream = None if stream is None: stream = self._createInputStream() self._sub_istream = weakref_ref(stream) return stream
def __init__(self, session, name, project=None): if project: mta = project.mta() else: mta = session.mta() project = session.project() self.session = weakref_ref(session) ProjectAgent.__init__(self, project, name, mta=mta) self.activate()
def __init__(self, session, server, socket, address, family): self.server = weakref_ref(server) self.socket = socket self.address = address self.family = family name = "net_client:" + formatAddress(self.family, self.address, short=True) SessionAgent.__init__(self, session, name) self.tx_bytes = 0 self.rx_bytes = 0
def __init__(self, component=None): # # These lines represent in-lining of the # following constructors: # - _ConstraintData, # - ActiveComponentData # - ComponentData self._component = weakref_ref(component) if (component is not None) \ else None self._active = True
def __init__(self, owner, value): # # The following is equivalent to calling # the base ComponentData constructor. # self._component = weakref_ref(owner) # # The following is equivalent to calling the # base NumericValue constructor. # self.value = value
def empty_model(model): logger.debug("Storing pyomo model to disk") rules = {} for obj in model.component_objects(ctype=Constraint): if obj.rule is not None: rules[obj.name] = obj.rule obj.rule = None bounds = {} for obj in model.component_objects(ctype=Var): if obj._bounds_init_rule is not None: bounds[obj.name] = obj._bounds_init_rule obj._bounds_init_rule = None smap_id, symbol_map = (next(iteritems(model.solutions.symbol_map)) if model.solutions.symbol_map else (None, None)) if smap_id is not None: for m in ('bySymbol', 'aliases'): setattr(symbol_map, m, {n: ComponentUID(obj()) for n, obj in iteritems(getattr(symbol_map, m))}) fd, fn = tempfile.mkstemp() with os.fdopen(fd, 'wb') as f: pickle.dump(model.__getstate__(), f, -1) model.__dict__.clear() logger.debug("Stored pyomo model to disk") gc.collect() yield logger.debug("Reloading pyomo model") with open(fn, 'rb') as f: state = pickle.load(f) os.remove(fn) model.__setstate__(state) for n, rule in iteritems(rules): getattr(model, n).rule = rule for n, bound in iteritems(bounds): getattr(model, n)._bounds_init_rule = bound if smap_id is not None: for m in ('bySymbol', 'aliases'): setattr(symbol_map, m, {n: weakref_ref(cuid.find_component(model)) for n, cuid in iteritems(getattr(symbol_map, m))}) symbol_map.byObject = {id(obj()): symb for symb, obj in iteritems(symbol_map.bySymbol)} model.solutions.symbol_map[smap_id] = symbol_map logger.debug("Reloaded pyomo model")
def __init__(self, expr, component=None): # # These lines represent in-lining of the # following constructors: # - _ExpressionData # - ComponentData # - NumericValue self._component = weakref_ref(component) if (component is not None) \ else None self._expr = as_numeric(expr) if (expr is not None) else None
def __init__(self, component): # # The following is equivalent to calling # the base ComponentData constructor. # self._component = weakref_ref(component) # # The following is equivalent to calling the # base NumericValue constructor. # self._value = _NotValid
def setupMTA(self, mta, logger=None): if mta: if logger: self.logger = logger else: self.logger = mta.logger self.mta = weakref_ref(mta) self.mailbox = Mailbox(self, mta) else: self.logger = None self.mta = None self.mailbox = None
def __init__(self, expr, sense=minimize, component=None): _GeneralExpressionDataImpl.__init__(self, expr) # Inlining ActiveComponentData.__init__ self._component = weakref_ref(component) if (component is not None) \ else None self._active = True self._sense = sense if (self._sense != minimize) and \ (self._sense != maximize): raise ValueError("Objective sense must be set to one of " "'minimize' (%s) or 'maximize' (%s). Invalid " "value: %s'" % (minimize, maximize, sense))
def __init__(self, application): ProjectAgent.__init__(self, self, "project", mta=application.mta()) self.application = weakref_ref(application) self.agents = AgentList() if RUNNING_LINUX: if application.options.fast: self.system_calm = SystemCalm(0.75, 0.2) elif not application.options.slow: self.system_calm = SystemCalm(0.50, 0.5) else: self.system_calm = SystemCalm(0.30, 3.0) else: self.warning("SystemCalm class is not available") self.system_calm = None # Configuration self.max_session = application.options.session self.success_score = 0.50 # minimum score for a successful session self.error_score = -0.50 # maximum score for a session failure self.max_success = application.options.success # Session self.session = None self.session_index = 0 self.session_timeout = None # in second # Statistics self.session_executed = 0 self.session_total_duration = 0 self.total_duration = None # Add Application agents, order is important: MTA have to be the first agent for agent in application.agents: self.registerAgent(agent) self.registerAgent(self) # Create aggressivity agent self.aggressivity = AggressivityAgent(self) # Initial aggresssivity value if application.options.aggressivity is not None: self.aggressivity.setValue(application.options.aggressivity / 100) self.error("Initial aggressivity: %s" % self.aggressivity)
def createSymbol(self, obj, labeler=None, *args): """ Create a symbol for an object with a given labeler. No error checking is done to ensure that the generated symbol name is unique. """ #if args: # symb = labeler(obj, *args) #else: # symb = labeler(obj) if labeler: symb = labeler(obj) elif self.default_labeler: symb = self.default_labeler(obj) else: symb = str(obj) self.byObject[id(obj)] = symb self.bySymbol[symb] = weakref_ref(obj) return symb
def insert(self, i, item): if isinstance(item, self._interface_datatype): if item._component is None: item._component = weakref_ref(self) if hasattr(self, "_active"): self._active |= getattr(item, '_active', True) self._data.insert(i, item) return # see note about allowing components to live in more than # one container raise ValueError( "Invalid component object assignment to ComponentList " "%s at index %s. A parent component has already been " "assigned the object: %s" % (self.name, i, item.parent_component().name)) # see note about implicit assignment and update raise TypeError("ComponentList must be assigned objects " "of type %s. Invalid type for key %s: %s" % (self._interface_datatype.__name__, i, type(item)))
def __setstate__(self, state): """Restore a picked state into this instance. Note: adapted from class ComponentData in pyomo.core.base.component """ if state['_associated_binary'] is not None and type( state['_associated_binary']) is not weakref_ref: state['_associated_binary'] = weakref_ref( state['_associated_binary']) _base = super(_GeneralBooleanVarData, self) if hasattr(_base, '__setstate__'): _base.__setstate__(state) else: for key, val in iteritems(state): # Note: per the Python data model docs, we explicitly # set the attribute using object.__setattr__() instead # of setting self.__dict__[key] = val. object.__setattr__(self, key, val)
def __init__(self,**kwds): self.strokeWidth = kwds.pop('strokeWidth',1) self.strokeColor = kwds.pop('strokeColor',colors.black) self.strokeDashArray = kwds.pop('strokeDashArray',None) self.crossWidth = kwds.pop('crossWidth',5) self.crossLo = kwds.pop('crossLo',None) self.crossHi = kwds.pop('crossHi',None) self.boxWidth = kwds.pop('boxWidth',None) self.boxFillColor = kwds.pop('boxFillColor',None) self.boxStrokeColor =kwds.pop('boxStrokeColor',NotSetOr._not_set) self.boxStrokeWidth =kwds.pop('boxStrokeWidth',NotSetOr._not_set) self.boxStrokeDashArray =kwds.pop('boxStrokeDashArray',NotSetOr._not_set) self.boxLo = kwds.pop('boxLo',None) self.boxMid = kwds.pop('boxMid',None) self.boxHi = kwds.pop('boxHi',None) self.boxSides = kwds.pop('boxSides',True) self.position = kwds.pop('position',None) self.candleKind = kwds.pop('candleKind','vertical') self.axes = kwds.pop('axes',['categoryAxis','valueAxis']) chart = kwds.pop('chart',None) self.chart = weakref_ref(chart) if chart else (lambda:None)
def __init__(self, component=None): # # These lines represent in-lining of the # following constructors: # - _VarData # - ComponentData # - NumericValue self._component = weakref_ref(component) if (component is not None) \ else None self._value = None # # The type of the lower and upper bound attributes can either be # atomic numeric types in Python, expressions, etc. Basically, # they can be anything that passes an "not # is_potentially_variable" test. # self._lb = None self._ub = None self._domain = None self._fixed = False self._stale = 0 # True
def __setitem__(self, i, item): if isinstance(item, self._interface_datatype): if item._component is None: item._component = weakref_ref(self) self._active |= getattr(item, '_active', True) # release the current component (assuming we don't get # an index error) # * see __delitem__ for explanation self._data[i]._component = None self._data[i] = item return # see note about allowing components to live in more than # one container raise ValueError( "Invalid component object assignment to ComponentList " "%s at index %s. A parent component has already been " "assigned the object: %s" % (self.cname(True), i, item.parent_component().cname(True))) # see note about implicit assignment and update raise TypeError("ComponentList must be assigned objects " "of type %s. Invalid type for key %s: %s" % (self._interface_datatype.__name__, i, type(item)))
def __getitem__(self, x): x = tuple(x) if isinstance(x, (tuple, list)) else (x, ) try: return self._children[x] except KeyError: Klass = self._value.__class__ if Klass in _ItemWrapper: WKlass = _ItemWrapper[Klass] else: _ItemWrapper[Klass] = WKlass = self.wKlassFactory(Klass) child = WKlass() for i in filter(lambda x, K=list(child.__dict__.keys()): x in K, list(child._attrMap.keys())): del child.__dict__[i] child.__dict__.update( dict(__propholder_parent__=weakref_ref(self), __propholder_index__=x[:-1])) self._children[x] = child return child
def __init__(self, instance, resolution_level=0, trace=False): """ Create a weak reference for 'instance' to observe an object but which won't prevent its deletion (which is monitored by the finalize callback). The size of the object is recorded in 'snapshots' as (timestamp, size) tuples. """ self.ref = weakref_ref(instance, self.finalize) self.id = id(instance) self.repr = '' self.name = str(instance.__class__) self.birth = _get_time() self.death = None self._resolution_level = resolution_level self.trace = None if trace: self._save_trace() initial_size = asizeof.basicsize(instance) or 0 size = asizeof.Asized(initial_size, initial_size) self.snapshots = [(self.birth, size)]
def construct(self, data=None): """ Initialize this component. """ if self._constructed: return timer = ConstructionTimer(self) if not self.is_indexed(): self._data[None] = self self._initialize_members((None,)) else: self_weakref = weakref_ref(self) for ndx in self._index: if ndx not in self._data: self._data[ndx] = _AdjustableVarData(self) self._component = self_weakref self._initialize_members(self._index) self._constructed = True timer.report()
def construct(self, data=None): """Construct this component.""" if __debug__ and logger.isEnabledFor(logging.DEBUG): #pragma:nocover try: name = str(self.name) except: # Some Var components don't have a name yet, so just use # the type name = type(self) if logger.isEnabledFor(logging.DEBUG): logger.debug( "Constructing Variable, name=%s, from data=%s" % (name, str(data))) if self._constructed: return timer = ConstructionTimer(self) self._constructed=True # # Construct _VarData objects for all index values # if not self.is_indexed(): self._data[None] = self self._initialize_members((None,)) elif self._dense: # This loop is optimized for speed with pypy. # Calling dict.update((...) for ...) is roughly # 30% slower self_weakref = weakref_ref(self) for ndx in self._index: cdata = self._ComponentDataClass( domain=self._domain_init_value, component=None) cdata._component = self_weakref self._data[ndx] = cdata #self._initialize_members((ndx,)) self._initialize_members(self._index) timer.report()
def __setstate__(self, state): """ This method must be defined to support pickling because this class owns weakrefs for '_parent'. """ if state['_parent'].__class__ not in _ref_types: state['_parent'] = weakref_ref(state['_parent']) # # Note: our model for setstate is for derived classes to modify # the state dictionary as control passes up the inheritance # hierarchy (using super() calls). All assignment of state -> # object attributes is handled at the last class before 'object' # (which may -- or may not (thanks to MRO) -- be here. # _base = super(Component, self) if hasattr(_base, '__setstate__'): _base.__setstate__(state) else: for key, val in state.items(): # Note: per the Python data model docs, we explicitly # set the attribute using object.__setattr__() instead # of setting self.__dict__[key] = val. object.__setattr__(self, key, val)
def __setitem__(self, key, val): if isinstance(val, self._interface_datatype): if val._component is None: val._component = weakref_ref(self) if hasattr(self, "_active"): self._active |= getattr(val, '_active', True) if key in self._data: # release the current component # * see __delitem__ for explanation self._data[key]._component = None self._data[key] = val return # see note about allowing components to live in more than # one container raise ValueError( "Invalid component object assignment to ComponentDict " "%s at key %s. A parent component has already been " "assigned the object: %s" % (self.cname(True), key, val.parent_component().cname(True))) # see note about implicit assignment and update raise TypeError("ComponentDict must be assigned objects " "of type %s. Invalid type for key %s: %s" % (self._interface_datatype.__name__, key, type(val)))
def alias(self, obj, name): """ Create an alias for an object. An aliases are symbols that do not have a one-to-one correspondence with objects. """ if name in self.aliases: # # If the alias exists and the objects are the same, # then return. Otherwise, raise an exception. # old_object = self.aliases[name]() if old_object is obj: return else: raise RuntimeError( "Duplicate alias '%s' already associated with " "component '%s' (conflicting component: '%s')" % (name, "UNKNOWN" if old_object is None else old_object.name, obj.name) ) else: # # Add the alias # self.aliases[name] = weakref_ref(obj)
def construct(self, data=None): """Construct this component.""" if is_debug_set(logger): #pragma:nocover try: name = str(self.name) except: name = type(self) logger.debug("Constructing Variable, name=%s, from data=%s" % (name, str(data))) if self._constructed: return timer = ConstructionTimer(self) self._constructed = True # # Construct _BooleanVarData objects for all index values # if not self.is_indexed(): self._data[None] = self self._initialize_members((None, )) elif self._dense: # This loop is optimized for speed with pypy. # Calling dict.update((...) for ...) is roughly # 30% slower self_weakref = weakref_ref(self) for ndx in self._index_set: cdata = self._ComponentDataClass(component=None) cdata._component = self_weakref self._data[ndx] = cdata # NOTE: This is a special case where a key, value pair is added # to the _data dictionary without calling # _getitem_when_not_present, which is why we need to set the # index here. cdata._index = ndx self._initialize_members(self._index_set) timer.report()
def __setstate__(self, state): """Restore a pickled state into this instance Note: our model for setstate is for derived classes to modify the state dictionary as control passes up the inheritance hierarchy (using super() calls). All assignment of state -> object attributes is handled at the last class before 'object' (which may -- or may not (thanks to MRO) -- be here. This method must be defined to support unpickling because this class owns weakrefs for '_component', which must be restored from the hard references used in the piclke. """ # # FIXME: We shouldn't have to check for weakref.ref here, but if # we don't the model cloning appears to fail (in the Benders # example) # if state['_component'] is not None and \ type(state['_component']) is not weakref_ref: state['_component'] = weakref_ref(state['_component']) # # Note: our model for setstate is for derived classes to modify # the state dictionary as control passes up the inheritance # hierarchy (using super() calls). All assignment of state -> # object attributes is handled at the last class before 'object' # (which may -- or may not (thanks to MRO) -- be here. # _base = super(ComponentData, self) if hasattr(_base, '__setstate__'): _base.__setstate__(state) else: for key, val in iteritems(state): # Note: per the Python data model docs, we explicitly # set the attribute using object.__setattr__() instead # of setting self.__dict__[key] = val. object.__setattr__(self, key, val)
def __setitem__(self, key, val): if isinstance(val, self._interface_datatype): if val._component is None: val._component = weakref_ref(self) if hasattr(self, "_active"): self._active |= getattr(val, '_active', True) if key in self._data: # release the current component # * see __delitem__ for explanation self._data[key]._component = None self._data[key] = val return elif (key in self._data) and (self._data[key] is val): # a very special case that makes sense to handle # because the implied order should be: (1) delete # the object at the current index, (2) insert the # the new object. This performs both without any # actions, but it is an extremely rare case, so # it should go last. return # see note about allowing components to live in more than # one container raise ValueError( "Invalid component object assignment to ComponentDict " "%s at key %s. A parent component has already been " "assigned the object: %s" % (self.name, key, val.parent_component().name)) # see note about implicit assignment and update raise TypeError( "ComponentDict must be assigned objects " "of type %s. Invalid type for key %s: %s" % (self._interface_datatype.__name__, key, type(val)))
def construct(self, data=None): """ Initialize this component. """ if self._constructed: return timer = ConstructionTimer(self) nom = self._nominal if not self.is_indexed(): self._data[None] = self else: self_weakref = weakref_ref(self) for ndx in self._index: if ndx not in self._data: self._data[ndx] = _UncParamData(self) self._data[ndx]._nominal = nom[ndx] self._data[ndx]._value = nom[ndx] self._component = self_weakref self._constructed = True timer.report()
def _add_xor_constraint(self, disjunction, transBlock): # Put XOR constraint on the transformation block # We never do this for just a DisjunctionData because we need # to know about the index set of its parent component. So if # we called this on a DisjunctionData, we did something wrong. assert isinstance(disjunction, Disjunction) # check if the constraint already exists if disjunction._algebraic_constraint is not None: return disjunction._algebraic_constraint() # add the XOR (or OR) constraints to parent block (with # unique name) It's indexed if this is an # IndexedDisjunction, not otherwise orC = Constraint(disjunction.index_set()) transBlock.add_component( unique_component_name(transBlock, disjunction.getname(fully_qualified=True, name_buffer=NAME_BUFFER) +\ '_xor'), orC) disjunction._algebraic_constraint = weakref_ref(orC) return orC
def __init__(self, component=None): self._component = weakref_ref(component) if (component is not None) \ else None
def _transform_disjunct(self, obj, transBlock, bigM, arg_list, suffix_list): # deactivated -> either we've already transformed or user deactivated if not obj.active: if obj.indicator_var.is_fixed(): if value(obj.indicator_var) == 0: # The user cleanly deactivated the disjunct: there # is nothing for us to do here. return else: raise GDP_Error( "The disjunct '%s' is deactivated, but the " "indicator_var is fixed to %s. This makes no sense." % ( obj.name, value(obj.indicator_var) )) if obj._transformation_block is None: raise GDP_Error( "The disjunct '%s' is deactivated, but the " "indicator_var is not fixed and the disjunct does not " "appear to have been relaxed. This makes no sense. " "(If the intent is to deactivate the disjunct, fix its " "indicator_var to 0.)" % ( obj.name, )) if obj._transformation_block is not None: # we've transformed it, which means this is the second time it's # appearing in a Disjunction raise GDP_Error( "The disjunct '%s' has been transformed, but a disjunction " "it appears in has not. Putting the same disjunct in " "multiple disjunctions is not supported." % obj.name) # add reference to original disjunct on transformation block relaxedDisjuncts = transBlock.relaxedDisjuncts relaxationBlock = relaxedDisjuncts[len(relaxedDisjuncts)] # we will keep a map of constraints (hashable, ha!) to a tuple to # indicate what their M value is and where it came from, of the form: # ((lower_value, lower_source, lower_key), (upper_value, upper_source, # upper_key)), where the first tuple is the information for the lower M, # the second tuple is the info for the upper M, source is the Suffix or # argument dictionary and None if the value was calculated, and key is # the key in the Suffix or argument dictionary, and None if it was # calculated. (Note that it is possible the lower or upper is # user-specified and the other is not, hence the need to store # information for both.) relaxationBlock.bigm_src = {} relaxationBlock.localVarReferences = Block() obj._transformation_block = weakref_ref(relaxationBlock) relaxationBlock._srcDisjunct = weakref_ref(obj) # This is crazy, but if the disjunction has been previously # relaxed, the disjunct *could* be deactivated. This is a big # deal for Hull, as it uses the component_objects / # component_data_objects generators. For BigM, that is OK, # because we never use those generators with active=True. I am # only noting it here for the future when someone (me?) is # comparing the two relaxations. # # Transform each component within this disjunct self._transform_block_components(obj, obj, bigM, arg_list, suffix_list) # deactivate disjunct to keep the writers happy obj._deactivate_without_fixing_indicator()
def associate_binary_var(self, binary_var): """Associate a binary _VarData to this _GeneralBooleanVarData""" self._associated_binary = weakref_ref(binary_var) if binary_var is not None else None
def add_solution(self, solution, smap_id, delete_symbol_map=True, cache=None, ignore_invalid_labels=False, ignore_missing_symbols=True, default_variable_value=None): instance = self._instance() soln = ModelSolution() soln._metadata['status'] = solution.status if not type(solution.message) is UndefinedData: soln._metadata['message'] = solution.message if not type(solution.gap) is UndefinedData: soln._metadata['gap'] = solution.gap if smap_id is None: # # Cache symbol names, which might be re-used in subsequent # calls to add_solution() # if cache is None: cache = {} if solution._cuid: # # Loading a solution with CUID keys # if len(cache) == 0: for obj in instance.component_data_objects(Var): cache[ComponentUID(obj)] = obj for obj in instance.component_data_objects(Objective, active=True): cache[ComponentUID(obj)] = obj for obj in instance.component_data_objects(Constraint, active=True): cache[ComponentUID(obj)] = obj for name in ['problem', 'objective', 'variable', 'constraint']: tmp = soln._entry[name] for cuid, val in getattr(solution, name).items(): obj = cache.get(cuid, None) if obj is None: if ignore_invalid_labels: continue raise RuntimeError( "CUID %s is missing from model %s" % (str(cuid), instance.name)) tmp[id(obj)] = (weakref_ref(obj), val) else: # # Loading a solution with string keys # if len(cache) == 0: for obj in instance.component_data_objects(Var): cache[obj.name] = obj for obj in instance.component_data_objects(Objective, active=True): cache[obj.name] = obj for obj in instance.component_data_objects(Constraint, active=True): cache[obj.name] = obj for name in ['problem', 'objective', 'variable', 'constraint']: tmp = soln._entry[name] for symb, val in getattr(solution, name).items(): obj = cache.get(symb, None) if obj is None: if ignore_invalid_labels: continue raise RuntimeError( "Symbol %s is missing from model %s" % (symb, instance.name)) tmp[id(obj)] = (weakref_ref(obj), val) else: # # Map solution # smap = self.symbol_map[smap_id] for name in ['problem', 'objective', 'variable', 'constraint']: tmp = soln._entry[name] for symb, val in getattr(solution, name).items(): if symb in smap.bySymbol: obj = smap.bySymbol[symb] elif symb in smap.aliases: obj = smap.aliases[symb] elif ignore_missing_symbols: continue else: #pragma:nocover # # This should never happen ... # raise RuntimeError( "ERROR: Symbol %s is missing from " "model %s when loading with a symbol map!" % (symb, instance.name)) tmp[id(obj())] = (obj, val) # # Wrap up # if delete_symbol_map: self.delete_symbol_map(smap_id) # # Collect fixed variables # tmp = soln._entry['variable'] for vdata in instance.component_data_objects(Var): id_ = id(vdata) if vdata.fixed: tmp[id_] = (weakref_ref(vdata), {'Value': value(vdata)}) elif (default_variable_value is not None) and \ (smap_id is not None) and \ (id_ in smap.byObject) and \ (id_ not in tmp): tmp[id_] = (weakref_ref(vdata), { 'Value': default_variable_value }) self.solutions.append(soln) return len(self.solutions) - 1
def __setstate__(self, state): for key, val in state.items(): setattr(self, key, val) # Restore the instance weakref self._instance = weakref_ref(self._instance)
def __init__(self, instance): self._instance = weakref_ref(instance) self.clear()
def __setstate__(self, state): super(_GeneralExpressionDataImpl, self).__setstate__(state) if safe_mode: if self._parent_expr is not None: self._parent_expr = weakref_ref(self._parent_expr)
def addSymbol(self, obj, symb): """ Add a symbol for a given object """ self.byObject[id(obj)] = symb self.bySymbol[symb] = weakref_ref(obj)
def __init__(self, owner, **kwargs): self._owner = weakref_ref(owner) super().__init__(**kwargs) self._component = weakref_ref(self) self.construct()
def __init__(self, expr, component=None): _GeneralExpressionDataImpl.__init__(self, expr) # Inlining ComponentData.__init__ self._component = weakref_ref(component) if (component is not None) \ else None
def __setstate__(self, state): _owner = state.pop('_owner') super().__setstate__(state) self._owner = None if _owner is None else weakref_ref(_owner)