PyEmofUC is a lightweight environment for the creation, processing and visualization of information following the Model-Driven Engineering paradigm (MDE).
Every artefact (model / meta-model) in this environment is formulated according to the EMOF 2.4 OMG specification.

The environment has been implemented using the Python language and thereby, it is:

• Multiplatform: It runs on any platform with a Python 2.7 interpreter.
  
• Open: It can handle any information formalized as EMOF models and accessible from the environment.
  
• Minimalist: It is a very lightweight Python package (7 modules and 2553 LoC) and its application interface is pretty simple (20 functions).
  Moreover, each model is a single XMI file and each transformation is a Python script.

The design of the PyEmofUC environment targets the following specific features:

• Technological spaces: PyEmofUC supports three technological spaces:

• The environment manages all artefacts in a uniform manner: The environment manages the meta-models (M2) as well as the models (M1) in a uniform way. The only exception is the EmofUC meta-meta-model, which is directly implemented from the environment code. It is inmutable and it is always available for any reflective query.
  

The PyEmofUC environment provides a public interface which can be used by the applications and tools processing the models data. The interface elements are the properties and operations declared in the AppRepository, MdlRepository, PyEmofObject and Element classes (along with their specialized classes in each model).

• Model management (AppRepository API) : The application repository (AppRepository) is responsible for the in-memory storage of the models on which an application works.
  It is often called application enviroment.
  

  Its public interface elements are:

• Property mdlRepositories => Reference to a set (dictionary) of models stored in the environment. (Note: This method should not be used as a shortcut for adding or removing single repositories because it will not set implicit references.)
• Operation getMdlRepository(uri) => It returns the reference to the model (mdlRepository) with the specified URI. If the model is not stored in the environment, the exception AppRepositoryError is raised.
• Operation hasMdlRepository(uri): PyBoolean => It returns True if the model is actually stored with the specified URI.
• Operation CreateMdlRepository(uri, date=None, mmUrl=None, importUrls=None) => It creates a new empty model in the application repository. The attributes of the newly created model are set to the values passed as arguments. The operation returns a reference to the new model.
• Operation getElement(uri,xmi_id): Element => It returns a reference to the element with the specified xmi_id attribute belonging to the model with the specified URI. If the element does not exist, the MdlRepositoryError exception is raised and if the model does not exist, the AppRepositoryError is raised. 
• Operation loadModel(url) => It loads the model described by the serialized data stored in the file with locator url. Based on the URL format, the operation identifies the serialization format. The operation loads recursively all models and metamodels referenced by the model.

• Management of model elements (MdlRepository API): The model repository stores the model elements.
  It is often called model.
  

  Its public interface elements are:

• Property aRep <read only>: Reference to the application repository in which the model is registered. It is set when the model is created.
• Property date: It describes the model version (date, version code, etc.).
• Property uri <read only>: It represents the unique universal identifier of the model. Two models with equal uri are the same model. Its format is defined in the “emof.Uri” type. Its value is set when the model is created.
• Property nsPrefix <read only>: Prefix used as nickname of the URI when model elements are referenced from another model .
• Property mmUri <read only>: Universal identifier of the meta-model.
• Property mmUrl <read only>: Locator of the XMI file that contains the meta-model. The existence of an accessible locator is required. Its format is defined in the type “emof.Url” (example: "platform:FamiliaEmpresa/Familia_MM.xmi"). It is a read-only attribute whose value is set at model creation.
• Property mmRep <read only>: Reference to the meta-model (to the model repository that contains it).
• Property importedUrls <read only>: List of locators (in textual format) of other models referenced from the actual model. When a model is loaded, those other models listed here are also loaded. If other models not included in this list are referenced by the model elements, the references remain unresolved in textual format (situation that results in a warning, but not an error). Its value is set when the model is loaded or stored.
• Property importedModels <read only>: Dictionary that contains references to other modules loaded into the application repository and which are referenced from model elements. The dictionary key is the prefix of the referenced model.
• Property rootPackage: It references the root container of the model. When a new reference is set, all elements previously stored are removed.
• Property isMetamodel <is derived>: It returns True if the model is a mata-model, i. e. if its meta-model is the EmofUC meta-meta-model.
• Property currentUrl <read only>: Valid URL of the model that is currently stored in the enviroment. It is set when the model is loaded or stored. It is set to None when a new element is added to the model or when a stored element is modified.
• Operation getElements():Element[0..*] => It returns the list containing the model elements.
• Operation getElementXmiIds():XMI_Identifier[0..*] => It teturns the list with the identifiers (xmi_id) of the model elements.
• Operation getElement(xmi_id):Element => It returns the reference to the model element with the specified xmi_id. If the element does not belong to the model, the MdlRepositoryError exception is raised.
• Operation hasElement(xmi_id): PyBoolean => it returns True if the model has an element with the specified xmi_id.
• Operation createElement(self, metaclass, xmi_id) : Element => It creates a model element that is an instance of the meta-class passed as argument. The created element is registered in the repository.  If it already exists, the operation does not create a new one, but returns a reference to it.
• Operation dumpModel(url,schemaUrl=None) => It generates a text file or character stream containing the model data. The textual format depends on the file extension (".xmi" generates XMI format, "txt" generates flat DSL format and "rtf" a rich text format with colored keywords.
  
• Operation nextXmiId(): XMI_Identifier => It returns a new valid and unique identifier every time it is called. That id is used to be assigned to the xmi_id property when creation of a new element.

• Management of attributes of the enviroment itself (PyEmofObject): PyEmofObject is the root class of all EmofUC elements. It provides the attributes that the PyEmofUC environment requires for managing model elements.
  

  It defines the following reflective operations, inherited by all elements.

• Property xmi_id <is read only>: It uniquely identifies an element within a model. It is used as a common identifier in all technological spaces (hence its name). It is assigned during element construction.
• Property metaclass<is read only>: It references the meta-model element that describes the element data structure (properties) and behavior (operations). This reference is the basis for the reflecivity capabilities of the PyEmofUC environment.
• Propiedad owner<is read only>: It references the model where the element has been created. It is assigned during element construction.
• Propiedad pyClass<is read only>: It references the Phyton class which is instantiated : it only has assigned value in the following cases:
• If the element belongs to the meta-meta-model (M3), the property references a class of the Python module emof.core.py.
• If the element belongs to a meta-model (M2) the property points to a class that is created when the meta-model is loaded.
• If the element is an EnumerationLiteral, the property references the literal Python value. It is assigned when the meta-model where the literal is defined is loaded.
• If the element is an Operation, the property references the corresponding Python operation.
• If the element belongs to a model (M1), its value is always None.
• Operation isInstanceOf(metamodelType) : PyBoolean => Reflective method that returns True if the model element on which it is applied is an instance of the meta-model element identified by the parameter (metamodelType).  The metamodelType parameter may be either a reference or the exmi_id identifier of the meta-model element.
  
• Operation isSuperclassOf(modelType) : PyBoolean =>  Reflective method that returns True if the class on which it is applied is a super-class of the class referenced by the (modelType) parameter. It returns None if the PyEmofObject element is not a class. The method assumes that a class is the superclass of itself. 
• Operation metaclassByName(xmi_id) : Element => Reflective method that returns the reference to the meta-model (or meta-meta-model) element identified by the xmi_id parameter. It returns None if the element does not exist.
• Operation elementByName(xmi_id) : Element => Reflective method that returns the reference to the element of the same model whose xmi_id attribute is the parameter value.It returns None if the element does not exist. 
• Operation getAllProperties(): Property[0..*] => Reflective method that returns a dictionary {<xmi_id>,<property>} containing references to every property of the element on which it is applied.
• Operation getAllAttributes(): Property[0..*] => Reflective method that returns a dictionary {<xmi_id>,<property>} containing references to all the properties of DataType type (emof.PrimitiveType and emof.Enumeration) that have the element to which it applies.
• Operation getAllReferences(): Property[0..*] => Reflective method that returns a dictionary {<xmi_id>,<property>} containing references to all the properties that are references (with the attibute isComposite=False) to other elements.
• Operation getAllAggregations(): Property[0..*] => Reflective method that returns a dictionary {<xmi_id>,<property>} containing references to all the properties that are references (with the attibute isComposite=True) to other elements.
• Operation getContainer(): Element => Reflective method that returns the reference to the element container. (Note: In the PyEmofUC enviroment, every element is stored in the MdlRepository where it has been created. This repository is accessed by the property owner. This method refers to the container defined in the meta-model.)

• Management of model data (EMOF::Element and its specialized classes): Model data is formulated as a structure of aggregated elements and by means of the values assigned to their properties. On the other hand, a model behavior is formulated through the operations declared in the classes of its elements. The specialized classes of EMOF. Element are implemented as Python classes with the following characteristics:

• The properties of the EMOF classes are formulated in the Python classes as Python properties with same name and in addition with the appropriate default value.
• The operations of the EMOF classes are formulated in the Python classes as Python functions with same name, same parameters and same return type.

When a model is managed outside from an application memory space, it is represented by a text consisting of standard alphanumeric characters and where references are formalized as URIs (hyper-references) and  the models are accessed via URL locators. The textual formulation is useful in the following cases:

• Model persistence.
• Transmission across environments.
• Model visualization on a console for interpretation by a human operator.
• Model creation or modification using a plain textual editor or a smart XML editor.

Model serialization and deserialization (model creation from textual formulation) are performed through the dump() and loadModel() operations of the public interface.
Three serialization formats are used, namely:

• «model».xmi: XML tagged text formulated according to the XMI OMG specification (PyEmofUC specific XMI format).
• «model».txt: Plain text formulated according to a domain-specific grammar generated from the meta-model (PyEmofUC plain text format).
• «model».rtf: Plain text similar to the previous one but enhanced with syntax coloring. (PyEmofUC plain text with colour).