magic_model

Smarter Python Data Models

• aware of data store. If SQL, table/column does not exist it creates it. Can also store unknown attributes in json columns. If NoSQL, then it is smart enough to save as is.
• goes to and from json seemlessly
• Can be created/updated from dict or attributes
• validation... is valid
• Aware of changed fields and previous values
• Based on Models from Backbone js
• how to model relationships?

class MagicModel:
  
  changed = {}
  attributes = {}
  defaults = {}
  validation_errors = []
  id_attribute = 'id'

  # Create a new model with the specified attributes. 
  def __init( self, attributes, options )__:
    # apply defaults 
    # apply attributes
    # set changed to {}
    pass    
    
  # Return a copy of the model's `attributes` dict
  def to_json( self ):
    pass

  # sync to datastore
  def sync( self ):
    pass
    
  # Get the value of an attribute.
  def get( self, attr ):
    pass
  
  # Returns `true` if the attribute contains a value that is not null
  # or undefined.
  def has( self, attr ):
    pass
    
  # Set a hash of model attributes on the object
  def set( self, key, val, options ):
    pass
    
  # Remove an attribute from the model  
  def unset( self, attr ):
    pass
  
  # Clear all attributes on the model  
  def clear( self ):
    pass
    
  # Determine if the model has changed since the last `"change"` event.
  # If you specify an attribute name, determine if that attribute has changed.    
  def has_changed( self, attr = None ):
    pass

  # Return an object containing all the attributes that have changed, or
  # false if there are no changed attributes. 
  # You can also pass an attributes object to diff against the model,
  # determining if there *would be* a change.
  def changedAttributes( self, diff = None ):
    pass

  # Get the previous value of an attribute, recorded at the time the last
  # `"change"` event was fired.
  def previous( self, attr = None ):
    pass

  # Get all of the attributes of the model at the time of the previous
  # `"change"` event.
  def previous_attributes( self ):
    pass
    
  # Fetch the model from the server. If the server's representation of the
  # model differs from its current attributes, they will be overridden,    
  def fetch( self ): 
    pass

  # Set a hash of model attributes, and sync the model to the server.
  # If the server returns an attributes hash that differs, the model's
  # state will be `set` again.
  def save( self ):
    pass

  # Destroy this model on the server if it was already persisted.
  def destroy( self ):
    pass

  # **parse** converts a response into the hash of attributes to be `set` on
  # the model. The default implementation is just to pass the response along.
  def parse( self, json ):
    pass

  # Create a new model with identical attributes to this one.
  def clone( self ): 
    pass

  # A model is new if it has never been saved to the server, and lacks an id.
  def isNew( self ): 
    pass

  # Run validation against the next complete set of model attributes,
  # returning `true` if all is well. Otherwise, fire an `"invalid"` event.  
  def validate( self, attrs ):  
    pass

  # Check if the model is currently in a valid state
  def is_valid( self ):  
    pass