modelverse/wrappers/modelverse.py

import urllib
import urllib2
import json
import random
from urllib2 import URLError

# Helper functions and configuration: do not use yourself!
taskname = random.random()
address = None
last_output = None
mode = 0

def _input(value):
    # Ugly json encoding of primitives
    value = '"%s"' if type(value) == str else value
    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": value, "taskname": taskname})))

def _input_raw(value, taskname):
    # Ugly json encoding of primitives
    urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "set_input", "value": value, "taskname": taskname})))

def _compile_AL(AL_file):
    # Compile an action language file and send the compiled code
    pass

def _compile_model(model_file):
    # Compile a model and send the compiled graph
    pass

def _output():
    try:
        global last_output
        last_output = urllib2.urlopen(urllib2.Request(address, urllib.urlencode({"op": "get_output", "taskname": taskname})))
        return last_output
    except:
        raise UnknownError()

def _output_last():
    return last_output

# Exceptions
class UnknownError(Exception):
    pass

class UnknownIdentifier(Exception):
    pass

class UnknownType(Exception):
    pass

class UnsupportedValue(Exception):
    pass

class CompilationError(Exception):
    pass

class NoSuchAttribute(Exception):
    pass

class UnknownModel(Exception):
    pass

class ConnectionError(Exception):
    pass

class ModelExists(Exception):
    pass

class PermissionDenied(Exception):
    pass

class InvalidMode(Exception):
    pass

# Main MvC operations
def init(address_param="http://localhost:8001"):
    """Starts up the connection to the Modelverse."""
    # return None
    # raises ConnectionError
    # raises UnknownError
    # raises InvalidMode
    global mode
    if mode != 0:
        raise InvalidMode()
    global address
    address = address_param
    try:
        _input_raw('"%s"' % taskname, "user_manager")
        mode = 1
    except URLError as e:
        raise ConnectionError(e.reason)
    except Exception as e:
        raise UnknownError(str(e))

def login(username, password):
    """Log in an existing user."""
    # return None
    # raises UnknownError
    # raises PermissionDenied
    global mode
    if mode != 1:
        raise InvalidMode()
    try:
        _input(username)
        _input(password)
        mode = 2
    except Exception as e:
        raise UnknownError(str(e))

def register(username, password):
    """Register a new user."""
    # return None
    # raises UnknownError
    # raises UserExists
    global mode
    if mode != 1:
        raise InvalidMode()
    try:
        _input(username)
        _input(password)
        _input(password)
        mode = 2
    except Exception as e:
        raise UnknownError(str(e))

def model_add(model_name, metamodel_name):
    """Instantiate a new model."""
    # return None
    # raises UnknownModel
    # raises ModelExists
    # raises UnknownError
    if mode != 2:
        raise InvalidMode()
    try:
        _input("model_add")
        _input(metamodel_name)
        _input(model_name)
    except Exception as e:
        raise UnknownError(str(e))

def model_modify(model_name):
    """Modify an existing model."""
    # return is_write
    # raises UnknownModel
    # raises PermissionDenied
    # raises UnknownError
    global mode
    if mode != 2:
        raise InvalidMode()
    try:
        _input("model_modify")
        _input(model_name)
        mode = 3
        _input("help")
        _output()
        if ("r/w" in _output()):
            write = True
        else:
            write = False
        _output()
        return write
    except Exception as e:
        raise UnknownError(str(e))

def model_list():
    """List all models."""
    # return [(model1, metamodel1), (model2, metamodel2), ...]
    # raises UnknownError
    if mode != 2:
        raise InvalidMode()
    try:
        _input("model_list")
        lst = []
        while (_output() != "Ready for command..."):
            v = _last_output()
            m, mm = v.split(":")
            m.trim()
            mm.trim()
            lst.append((m, mm))
        return lst
    except Exception as e:
        raise UnknownError(str(e))

def model_list_full():
    """List full information on all models."""
    # return [(model1, metamodel1, owner1, group1, permissions1), (model2, metamodel2, owner2, group2, permissions2), ...]
    # raises UnknownError
    if mode != 2:
        raise InvalidMode()
    try:
        _input("model_list_full")
        lst = []
        while (_output() != "Ready for command..."):
            v = _last_output()
            m, mm = v.split(":")
            m.trim()
            mm.trim()
            perm, own, grp, m = m.split(" ")
            lst.append((m, mm, own, grp, perm))
        return lst
    except Exception as e:
        raise UnknownError(str(e))

def model_overwrite(model_name, new_model):
    """Upload a new model and overwrite an existing model."""
    # return None
    # raises UnknownModel
    # raises PermissionDenied
    # raises CompilationError
    # raises UnknownError
    if mode != 2:
        raise InvalidMode()
    try:
        _input("model_overwrite")
        _input(model_name)
        _compile_model(new_model)
    except Exception as e:
        raise UnknownError(str(e))

def user_logout():
    """Log out the current user. A new login will be required afterwards."""
    # return None
    # raises UnknownException
    global mode
    if mode != 2:
        raise InvalidMode()
    try:
        _input("exit")
        mode = 1
    except Exception as e:
        raise UnknownError(str(e))

def user_delete():
    """Removes the current user. A new login will be required afterwards."""
    # return None
    # raises UnknownException
    global mode
    if mode != 2:
        raise InvalidMode()
    try:
        _input("self-destruct")
        mode = 1
    except Exception as e:
        raise UnknownError(str(e))

# Actual operations on the model
def list():
    """Return a list of all IDs and the type of the element"""
    # return [(name1, type1), (name2, type2), ...]
    # raises UnknownError
    if mode != 3:
        raise InvalidMode()
    try:
        _input("list")
        lst = []
        while (_output() != "Ready for command..."):
            v = _last_output()
            m, mm = v.split(":")
            m.trim()
            mm.trim()
            lst.append((m, mm))
        return lst
    except Exception as e:
        raise UnknownError(str(e))

def types():
    """Return a list of all types usable in the model"""
    # return [type1, type2, ...]
    # raises UnknownError
    if mode != 3:
        raise InvalidMode()
    try:
        _input("types")
        lst = []
        while (_output() != "Ready for command..."):
            v = _last_output()
            m, mm = v.split(":")
            m.trim()
            lst.append(m)
        return lst
    except Exception as e:
        raise UnknownError(str(e))

def read(ID):
    """Return a tuple of information on the element: its type and source/target (None if not an edge)"""
    # return (type, (source, target))
    # raises UnknownError
    # raises UnknownIdentifier
    if mode != 3:
        raise InvalidMode()
    try:
        _input("read")
        _input(ID)
        _output()
        t = _output().split(":")[1].trim()
        if (not _output().startswith("Source:")):
            rval = (t, None)
        else:
            src = _last_output().split(":")[1].trim()
            trg = _output().split(":")[1].trim()
            rval = (t, (src, trg))
        while (_output() != "Ready for command..."):
            pass
        return rval
    except Exception as e:
        raise UnknownError(str(e))

def read_attrs(ID):
    """Return a dictionary of attribute value pairs"""
    # return {attr1: value1, attr2: value2, ...}
    # raises UnknownError
    if mode != 3:
        raise InvalidMode()
    try:
        _input("read")
        _input(ID)
        rval = {}
        while (_output() != "Attributes:"):
            pass
        while (_output() != "Ready for command..."):
            r = _last_output()
            key, value = r.split(":")
            _, value = value.split("=")
            key.trim()
            value.trim()
            rval[key] = value
        return rval
    except Exception as e:
        raise UnknownError(str(e))

def instantiate(typename, edge=None, ID=""):
    """Create a new instance of the specified typename, between the selected elements (if not None), and with the provided ID (if any)"""
    # return instantiated_ID
    # raises UnknownError
    # raises UnknownType
    # raises UnknownIdentifier
    if mode != 3:
        raise InvalidMode()
    try:
        _input("instantiate")
        _input(typename)
        _input(ID)
        if (edge is not None):
            _input(edge[0])
            _input(edge[1])
    except Exception as e:
        raise UnknownError(str(e))

def delete(ID):
    """Delete the element with the given ID"""
    # return None
    # raises UnknownError
    # raises UnknownIdentifier
    if mode != 3:
        raise InvalidMode()
    try:
        _input("delete")
        _input(ID)
    except Exception as e:
        raise UnknownError(str(e))

def attr_assign(ID, attr, value):
    """Assign a value to an attribute"""
    # return None
    # raises UnknownError
    # raises UnknownIdentifier
    # raises NoSuchAttribute
    # raises UnsupportedValue
    if mode != 3:
        raise InvalidMode()
    try:
        _input("attr_modify")
        _input(ID)
        _input(attr)
        _input(value)
    except Exception as e:
        raise UnknownError(str(e))

def attr_assign_code(ID, attr, code):
    """Assign a piece of Action Language code to the attribute"""
    # return None
    # raises UnknownError
    # raises UnknownIdentifier
    # raises NoSuchAttribute
    # raises UnsupportedValue
    if mode != 3:
        raise InvalidMode()
    try:
        _input("attr_modify")
        _input(ID)
        _input(attr)
        _compile_AL(code)
    except Exception as e:
        raise UnknownError(str(e))

def upload(new_model):
    """Overwrite the current model with the provided model"""
    # return None
    # raises UnknownError
    # raises CompilationError
    if mode != 3:
        raise InvalidMode()
    try:
        _input("upload")
        _compile_model(new_model)
    except Exception as e:
        raise UnknownError(str(e))

def read_outgoing(ID, typename):
    """Returns a list of all outgoing associations of a specific type ("" = all)"""
    # return [name1, name2, ...]
    # raises UnknownError
    # raises UnknownIdentifier
    # raises UnknownType
    if mode != 3:
        raise InvalidMode()
    try:
        _input("read_outgoing")
        _input(ID)
        _input(typename)
        lst = []
        while (_output() != "Please give your command."):
            lst.append(_last_output())
        return lst
    except Exception as e:
        raise UnknownError(str(e))

def read_incoming(ID, typename):
    """Returns a list of all incoming associations of a specific type ("" = all)"""
    # return [name1, name2, ...]
    # raises UnknownError
    # raises UnknownIdentifier
    # raises UnknownType
    if mode != 3:
        raise InvalidMode()
    try:
        _input("read_incoming")
        _input(ID)
        _input(typename)
        lst = []
        while (_output() != "Please give your command."):
            lst.append(_last_output())
        return lst
    except Exception as e:
        raise UnknownError(str(e))

def model_exit():
    """Leave model modify mode."""
    # return None
    # raises UnknownError
    global mode
    if mode != 3:
        raise InvalidMode()
    try:
        _input("exit")
        mode = 2
    except Exception as e:
        raise UnknownError(str(e))

def transformation_add_MT_language():
    """Create a new Model Transformation language out of a set of metamodels."""
    raise NotImplementedError()

def transformation_add_MT():
    """Create a new model transformation."""
    raise NotImplementedError()

def transformation_add_AL():
    """Create a new action language fragment."""
    raise NotImplementedError()

def transformation_add_MANUAL():
    """Create a new manual model operation."""
    raise NotImplementedError()

def transformation_execute():
    """Execute an existing model operation."""
    raise NotImplementedError()

def transformation_list():
    """List existing model operations."""
    raise NotImplementedError()

def transformation_list_full():
    """List detailed information on model operations."""
    raise NotImplementedError()

def transformation_detail():
    """List full details of a a model operation."""
    raise NotImplementedError()

def transformation_RAMify():
    """Ramify an existing metamodel."""
    raise NotImplementedError()

def process_execute():
    """Execute a process model."""
    raise NotImplementedError()

def permission_modify():
    """Modify permissions of a model."""
    raise NotImplementedError()

def permission_owner():
    """Modify the owning user of a model."""
    raise NotImplementedError()

def permission_group():
    """Modify the owning group of a model."""
    raise NotImplementedError()

def group_create():
    """Create a new group."""
    raise NotImplementedError()

def group_delete():
    """Delete a group of which you are an owner."""
    raise NotImplementedError()

def group_owner_add():
    """Add a new owning user to a group you own."""
    raise NotImplementedError()

def group_owner_delete():
    """Delete an owning user to a group you own."""
    raise NotImplementedError()

def group_join():
    """Add a new user to a group you own."""
    raise NotImplementedError()

def group_kick():
    """Delete a user from a group you own."""
    raise NotImplementedError()

def group_list():
    """List existing groups."""
    raise NotImplementedError()

def admin_promote():
    """Promote a user to admin status."""
    raise NotImplementedError()

def admin_demote():
    """Demote a user from admin status."""
    raise NotImplementedError()