Mindwrapper API

Abstraction Layer

• Contents

  Model Link Map Folder Unit Cabinet

  Cell Boolean YesNo Text Number Timepoint

• 
  Preface
  • The Abstraction Layer ...
    
    

• Model(Item):
  • Model is an abstract class, the base class for Link, Map, and Cell. Cells are leaf nodes in a directed, acyclic, labeled graph, and maps are branching nodes. Links allow for cyclic behavior. Labels can be in standard Python dot-notation for attributes, or in dot-notation strings used as subscripts. The methods __getattr__() and __setattr__() are redefined such that copy.deepcopy and pickle.dump() return an abstracted version having only non-derived subitems (see abstract() method below).
  • abstract(self)
    • Although public, this method is typically not invoked by the user-developer. It returns an abstracted deepcopy of the model. The abstract has no helper attributes (no observer list and no introspection attributes, for example) and no derived subitems. In other words, it consists only of non-derived subitems. The abstract is suitable for pickling.
  • is_derived(self)
    • Although public, this method is typically not invoked by the user-developer. It returns True if the model is derived and False if the model is independent (non-derived).
  • rekey(self, parent=None, name='')
    • Although public, this method is typically not invoked by the user-developer. A deepcopy or restored pickle of a model have no attributes to support introspection. These attributes can be restored through this method (which is overridden in Map to rekey subitems recursively).
    • parent
      • The parent object, if present, is restored.
    • name
      • The name string, if known, is restored.
  • get(self)
    • Although public, in Model this method is primitive and intended primarily for testing. It returns the abstract state of the model. This method is overridden specifically in Cell to return the value of the cell, and may be overridden in subclasses of Map to return a composite value.
  • set(self, state)
    • Although public, in Model this method is primitive and intended primarily for testing. It sets the abstract state of the model and notifies observers. This method is overridden specifically in Cell to set the value of the cell, and may be overridden in subclasses of Map to parse a composite value and set components.
    • state
      • For this nearly abstract primitive method, state is a dict. In subclasses subclasses, this parameter can be any value, scalar or composite that the overridding method can convert to the "state" of the model.
  • reset(self)
    • Although public, in Model this method is primitive and intended primarily for testing. It resets the abstract state of the model to None via set(). This method is overridden specifically in Cell to set the value of the cell to its default value, and in Map to reset all subitems recursively.
  • receive(self, source)
    • Although public, in Model this method is primitive and intended primarily for testing. It "actively" receives the state of the source to itself via set(), which notifies observers. This method is overridden specifically in Cell to set the value of the cell to the source value, and in Map to receive all subitems recursively (notifying observers of subitems recursively as well).
    • source
      • For all overridden versions in subclasses, as well as for this nearly abstract primitive method, source is another model, usually of the same class as this one.
  • accept(self, source)
    • This public method "passively" accepts the state of the source to itself without going through set() and without notifying observers (much faster than receive()). It is not overridden in subclasses.
    • source
      • The source parameter is another model, usually of the same class as this one.
  • add_observer(self, observer)
    • This public method may not be needed by the user-developer, as observers usually take responsibility for adding themselves to the observables. Either way, this method adds an observer to the observer list of the model (as a weak reference, so that if the observer is deleted, it is automatically removed from the list).
    • observer
      • The observer may be another model, or it may be a presenter.
  • remove_observer(self, observer)
    • Although public, this method is typically not invoked by the user-developer. If observers are deleted elsewhere, they are automatically removed from the observer list. Moreover, observers are typically permanent in most applications.
    • observer
      • The observer model or presenter to be removed from the observer list.
  • notify_observers(self, message)
    • Although public, this method is typically not invoked by the user-developer. When called from other methods it notifies all observers in the list of a change by calling the observer's update() method (with message as the parameter).
    • message
      • The message parameter may be a string or another object, but typically it will be a reference to the notifying model itself. The semantics must be correlated with the semantics of Item.update().
  • notify_all(self, message)
    • This public method may never be needed (possible YAGNI). When called, however,it notifies observers of this model and of all parent models up the line to the top.
    • message
      • The message parameter may be a string or another object, but typically it will be a reference to the actual notifying model (and not any of its parent observables). The semantics must be correlated with the semantics of Item.update().
• Link(Model):
  • Link is a concrete subclass of Model. A link is a node in the abstraction layer tree graph that points to a model (the target) elsewhere in the tree graph. It is intended to function as the target model in every way (having the same methods and values) without merely being a copy of the target.
  • __init__(self, parent=None, name='', target=Model)
    • The initializer generally requires two positional arguments for parent and name. Additional positional arguments are collected as references to external items. Keyword arguments are collected as specifiers.
    • parent, name
      • These two parameters are the same as for Item.__init__()
    • target
      • The target is usually a model (instance) supplied by the add() method of the container model. If a model class is given instead, this link becomes a placeholder for the timebeing, and the target instance must be supplied later using the link() method.
  • link(self, target)
    • This public method sets the target instance for a placeholder link that was previously created using the expected target class.
    • target
      • The target is the model instance to which this link points.
  • follow(self)
    • Although public, this method is typically not invoked by the user-developer. From wherever it is called, it returns the target model.
  • set_top(self, top)
    • Although public, this method is typically not invoked by the user-developer. It stores a reference to the top model, which along with the key locates the target.
    • top
      • The top parameter is the model at the top of the target's hierarchy.
  • set_key(self, key)
    • Although public, this method is typically not invoked by the user-developer. It stores the key for use in following the link.
    • key
      • The key is a string in dot-notation that names and, along with the top item, locates the target.
  • read_key(self)
    • Although public, this method is typically not invoked by the user-developer. This method is called from the Folder.save() method, for example. It returns a string in dot-notation that names and locates the target.
  • receive(self, source)
    • The semantics are the same as for Model.receive(), but the target is passively accepted from the source link.
    • source
      • The source is another link.
  • add_observer(self, observer)
    • The semantics are the same as for Model.add_observer(), but the observer is added to the target observer list.
    • observer
      • The observer may be a model or a presenter.
• Map(Model):
  • Map ...
  • specifiers
    • Class attributes are specifiers. The refs specifier is inherited from Item and one additional specifier is defined here:
    • type = Model
      • This specifier ... .
  • add (self, name='', item=None, *references, **specifiers)
    • A concrete implementation of the abstract method found in Item. Thus a map is a composite item to which other items are added either at runtime or at design-time.
    • name
      • ...
    • item
      • ... .
    • *references
      • Positional arguments other than name and item are references to external items needed by the added item. These arguments are typically item instances.
    • **specifiers
      • Keyword arguments are specifiers for the added item instance.
  • remove (self, name)
    • ....
  • items (self)
    • ....
  • sorteditems (self, key, keep=all)
    • ....
  • restricted (self, keep=all)
    • ....
  • values (self)
    • ....
  • clear (self)
    • ....
  • extract (self, source)
    • ....
  • update (self, source)
    • ....
• Folder(Map):
  • open (self, mode='n')
    • ....
  • save (self)
    • ....
  • close (self)
    • ....
• Unit(Folder):
  • execute (self, transaction)
    • ....
  • get_mode (self)
    • ....
• Cabinet(Folder):
  • __init__(self, parent=None, name='', dsn=None, uid=None, protocol=2)
    • This signature differs slightly from that of other Item subclasses because external references and class specifiers do not make sense here. Nonetheless, keyword arguments act as instance specifiers.
    • parent
      • Dummy argument not used.
    • name
      • An item name, if provided, is stored but has little meaning because there is no parent.
    • dsn
      • ...
    • uid
      • ...
    • protocol
      • ...
  • connect (self, dsn, create=False)
    • ....
  • disconnect (self)
    • ....
  • destroy (self)
    • ....
  • get_uid (self)
    • ....
  • get_path (self)
    • ....
  • get_protocol (self)
    • ....
• Cell(Model):
  • specifiers
    • Class attributes are specifiers.
    • forward -- propagate calculations forward
      • This specifier points to a function or static method for calculating the dependent value from independent values. When provided as a class specifier it may be defined using a def statement (with no self argument). When provided as an instance specifier, the value can be a function defined elsewhere or a lamda statement.
    • backward -- backpropagate calculations
      • ... .
    • default
      • ... .
    • constant
      • ... .
    • label
      • ... .
  • value
    • Property ....
  • extract (self, source)
    • ....
    • source
      • The source cell (usually positional argument).
  • update (self, source)
    • ....
    • source
      • Dummy argument not used here.
• Boolean(Cell):
  • specifiers
    • Class attributes are specifiers.
    • choices = ['True', 'False']
      • Only two choices.
  • text
    • Property ....
• YesNo(Boolean):
  • specifiers
    • Class attributes are specifiers.
    • choices = ['Yes', 'No']
      • Only two choices.
• Text(Cell):
  • specifiers
    • Class attributes are specifiers.
    • choices
      • Replace with list of choices.
    • more
      • Append a list of choices to previous choices.
  • text
    • Property ....
• Number(Cell):
  • specifiers
    • Class attributes are specifiers.
    • scale = 0
      • .....
    • digits = 2
      • ....
    • limits
      • .....
  • text
    • Property ....
  • scaled
    • Property ....
• Integer(Number):
• Kg(Number):
• Product(Number):
• Quotient(Number):
• Difference(Number):
• Sum(Number):
• Average(Number):
• Timepoint(Cell):
• Hours(Number):

• Key
  • Version 0.3 is an "unstable" version, meaning that the API is subject to change. Once version 0.4 is released, the public terms and their semantics are guaranteed not to change for any 0.4.n micro-version. Many public terms are not needed by the user-developer, but are made public for testing purposed. Public terms commonly invoked by the user-developer are considered keywords, some of which are abstract to be defined at design-time. Keywords also include properties. Named parameters that are more typically supplied as positional arguments are currently considered public terms but may not be in the future.
    
    

This page is licensed under a Creative Commons License.
XHTML 1.0 © 2002-2004 Donnal C. Walter, COM, UAMS
This page updated 2004-11-06.