bocl 0.1.0__py3-none-any.whl

bocl/Evaluator.py

@@ -0,0 +1,456 @@
+from besser.BUML.notations.ocl.FactoryInstance import Factory
+from besser.BUML.metamodel.ocl.rules import *
+from besser.BUML.metamodel.structural.structural import Property
+class Evaluator:
+    """The Evaluator class evaluates the OCL constraints based on the object model.
+
+    Args:
+
+    Attributes:
+            debug = this attribute is used for debugging purposes and with default value false
+            allObjSat = list of all objects that satisfy the contraint
+    """
+    def __init__(self):
+        self.debug = False
+        self.allObjSat = []
+
+
+    def get_value(self,name, obj):
+        """The get_value function to retrieve value of attribute from object.
+
+            Args:
+                        name: name of the attribute
+                        object: Object from object model
+            """
+        for slot in obj.slots:
+            if name == slot.attribute.name:
+                if slot.attribute.type.name == 'str':
+                    return '"'+ slot.value.value +'"'
+                else:
+                    return slot.value.value
+    def checkInObj(self,obj,source):
+        """The checkInObj function identifies the object that contains the source in slots.
+
+        Args:
+            obj: Object from object model
+            source: source of the current object in the CSTree
+        """
+        for s in obj.slots:
+            if s.attribute.name == source.name:
+                return obj
+    def checkInLinkEnds(self,obj, source):
+        """The checkInLinkEnds function identifies the source in the linkend of the object.
+
+        Args:
+            obj: Object from object model
+            source: source of the current object in the CSTree
+        """
+        toRet = []
+        for link in obj.links:
+            for connection in link.connections:
+                if connection.association_end.name == source.name:
+                    toRet.append(connection.object)
+
+        return toRet
+    def handleForAll(self, tree, allObjs, logicalExp):
+        """The handleForAll function handles forAll expression from OCL MM.
+
+        Args:
+                    tree: Tree that is constructed using OCL Parser
+                    allObjs: all objects from object model
+                    logicalExp: Expression to evaluate at the end to get the result
+        """
+        logicalExp[0] = logicalExp[0] +" ("
+        for index in range(len(allObjs)):
+            if len(tree.get_body)>0:
+                self.update_logical_exp(tree.get_body[0],logicalExp,allObjs[index])
+                if index < len(allObjs)-1:
+                    logicalExp[0] = logicalExp[0] + " and "
+        logicalExp[0] = logicalExp[0] +" )"
+        pass
+    def handle(self, source, obj, logicalExp,rightSide = False):
+        """The handle function handles Property Call expression from OCL MM.
+
+        Args:
+                    source: one child in OCL CST
+                    obj: one object from object model
+                    logicalExp: Expression to evaluate at the end to get the result
+                    rightSide: to identify the side of logical expression
+        """
+
+        if isinstance(source, PropertyCallExpression) or isinstance(source,Property):
+                # if len(source.name.split('.'))==2:
+                allObjs = self.checkInObj(obj,source)
+                if allObjs is None:
+                    allObjs = self.checkInLinkEnds(obj, source)
+                for index in range(len(allObjs)):
+                    objs = allObjs[index]
+                    if len(allObjs) > 1 or rightSide:
+                        logicalExp[0] = logicalExp[0] + " [ "
+                    for i in range (len(objs.slots)):
+                        logicalExp[0] = logicalExp[0] + "\""+str(objs.slots[i].attribute.name)+ str(objs.slots[i].value.value) + "\""
+                        if i < len(objs.slots)-1:
+                            logicalExp[0] = logicalExp[0]+","
+                    if not rightSide:
+                        if len(allObjs) > 1 and index< len(allObjs)-1:
+                            logicalExp[0] = logicalExp[0] + " ], "
+                    else:
+                        logicalExp[0] = logicalExp[0] + " ] "
+                        if len(allObjs) > 1 and index< len(allObjs)-1:
+                            logicalExp[0] = logicalExp[0] + " , "
+
+
+                pass
+        pass
+    def handleExcludes(self, tree, obj, logicalExp):
+        """The handleExcludes function handles excludes construct.
+
+        Args:
+                    tree: Tree that is constructed using OCL Parser
+                    obj: one object from object model
+                    logicalExp: Expression to evaluate at the end to get the result
+        """
+        # tempLogicalExp =[""]
+        args = tree.arguments
+        self.checkAndAdd(logicalExp, " and ")
+        logicalExp[0] = logicalExp[0] + " [ "
+        self.handle(tree.source, obj, logicalExp)
+        logicalExp[0] = logicalExp[0] + " ] not in "
+        if len(args)==1: #Property
+            logicalExp[0] = logicalExp[0] + " [ "
+            self.handle(args[0],obj,logicalExp,True)
+            logicalExp[0] = logicalExp[0] + " ]"
+        pass
+
+    def handleIncludes(self, tree, obj, logicalExp):
+        """The handleIncludes function handles includes construct.
+
+        Args:
+                    tree: Tree that is constructed using OCL Parser
+                    obj: one object from object model
+                    logicalExp: Expression to evaluate at the end to get the result
+        """
+
+        # tempLogicalExp =[""]
+        args = tree.arguments
+        self.checkAndAdd(logicalExp, " and ")
+        logicalExp[0] = logicalExp[0] + " [ "
+        self.handle(tree.source, obj, logicalExp)
+        logicalExp[0] = logicalExp[0] + " ] in "
+        if len(args)==1: #Property
+            logicalExp[0] = logicalExp[0] + " [ "
+            self.handle(args[0],obj,logicalExp,True)
+            logicalExp[0] = logicalExp[0] + " ]"
+        pass
+    def handleExists(self,tree,allObjs,logicalExp):
+        """The handleExists function handles exists construct.
+
+        Args:
+            tree: Tree that is constructed using OCL Parser
+            allObjs: all objects from object model
+            logicalExp: Expression to evaluate at the end to get the result
+        """
+        logicalExp[0] = logicalExp[0] + " ( "
+        temp = logicalExp[0]
+        for index in range(len(allObjs)):
+            if len(tree.get_body) > 0:
+                self.update_logical_exp(tree.get_body[0], logicalExp, allObjs[index])
+                if index < len(allObjs) - 1:
+                    logicalExp[0] = logicalExp[0] + " or "
+        if temp == logicalExp[0]:
+            logicalExp[0] = logicalExp[0] + " False "
+
+        logicalExp[0] = logicalExp[0] + " )"
+    def handleCollect(self,tree,allObjs,logicalExp):
+        """The handleCollect function handles collect construct.
+
+        Args:
+               tree: Tree that is constructed using OCL Parser
+               allObjs: all objects from object model
+               logicalExp: Expression to evaluate at the end to get the result
+        """
+        self.allObjSat.append([])
+        for obj in allObjs:
+            expression = [""]
+            if len(tree.get_body) > 0:
+                self.update_logical_exp(tree.get_body[0], expression, obj)
+                self.preprocessLogicalExp(expression)
+                if eval (expression[0]) == True:
+                    self.allObjSat[-1].append(obj)
+
+    def verifyBody (self,tree, obj,logicalExp,source,allObjs= None):
+        """The verifyBody function verifies the body of different constructs (e.g., forAll, exists).
+
+        Args:
+            tree: Tree that is constructed using OCL Parser
+            obj: one object from object model
+            logicalExp: Expression to evaluate at the end to get the result
+            source: source of the obj in CSTree
+        """
+        expressionType = tree.name
+        if allObjs is None:
+            allObjs = self.checkInObj(obj,source)
+            if allObjs is None:
+                allObjs = self.checkInLinkEnds(obj, source)
+        if source.name == "ALLInstances":
+                className = source.source.name
+                allObjs = self.getValidObjects(className, self.om)
+
+        if expressionType == "forAll":
+            self.handleForAll(tree, allObjs, logicalExp)
+        elif expressionType == "exists":
+            self.handleExists(tree,allObjs,logicalExp)
+        elif expressionType == "collect":
+            self.handleCollect(tree,allObjs,logicalExp)
+        elif expressionType == "select":
+            self.handleCollect(tree,allObjs,logicalExp)
+        pass
+    def getID(self,slots):
+        """The getID function gets the ID attribute from the Object.
+
+        Args:
+                    slots: slots of the object
+        """
+        for s in slots:
+            if s.get_attribute.is_id:
+                return s
+    def addToExp(self, item, logicalExp):
+        """The addToExp function adds the item to logicalExpression.
+
+        Args:
+              item: item to add in Logical Expression
+              logicalExp: logical Expression
+        """
+        if logicalExp[0] == "":
+            logicalExp[0] = logicalExp[0] + item
+        else:
+            logicalExp[0] = logicalExp[0] + " and "+item
+    def handleSize(self, tree,obj,logicalExp):
+        """The handleSize function handles the size construct.
+
+        Args:
+                    tree: Tree that is constructed using OCL Parser
+                    obj: one object from object model
+                    logicalExp: Expression to evaluate at the end to get the result
+        """
+        self.checkAndAdd(logicalExp , " and ")
+        logicalExp[0] = logicalExp[0] + "("
+        if isinstance(tree.source, Property):
+            allObjs = self.checkInObj(obj, tree.source)
+            if allObjs is None:
+                allObjs = self.checkInLinkEnds(obj, tree.source)
+            logicalExp[0] = logicalExp[0] + str(len(allObjs))
+            for arg in tree.arguments:
+
+                    if isinstance(arg, IntegerLiteralExpression) or isinstance(arg,
+                                                                               RealLiteralExpression) or isinstance(arg,
+                                                                                                                    BooleanLiteralExpression):
+                            logicalExp[0] = logicalExp[0] + str(arg.value)
+                    else:
+                        logicalExp[0] = logicalExp[0]+str(arg)
+        elif isinstance(tree.source,LoopExp):
+            if tree.source.source is not None:
+                source = tree.source.source
+            if source.name == "ALLInstances":
+                className = source.source.name
+                allObjs = self.getValidObjects(className, self.om)
+            else:
+                allObjs = self.checkInObj(obj, source)
+                if allObjs is None:
+                    allObjs = self.checkInLinkEnds(obj, source)
+            self.handleCollect(tree.source,allObjs,logicalExp)
+            if len(self.allObjSat)>0:
+                logicalExp[0] = logicalExp[0] +str(len(self.allObjSat[-1]))
+                self.allObjSat.pop()
+            for arg in tree.arguments:
+
+                    if isinstance(arg, IntegerLiteralExpression) or isinstance(arg,
+                                                                               RealLiteralExpression) or isinstance(arg,
+                                                                                                                    BooleanLiteralExpression):
+                            logicalExp[0] = logicalExp[0] + str(arg.value)
+                    else:
+                        logicalExp[0] = logicalExp[0]+str(arg)
+        logicalExp[0] = logicalExp[0] + ")"
+
+    def handleIFExp(self,tree, obj, logicalExp):
+        """The handleIFExp function handles the If construct.
+
+        Args:
+                    tree: Tree that is constructed using OCL Parser
+                    obj: one object from object model
+                    logicalExp: Expression to evaluate at the end to get the result
+        """
+
+        tempExp = [""]
+        self.update_logical_exp(tree.ifCondition, tempExp, obj)
+        self.preprocessLogicalExp(tempExp)
+        self.checkAndAdd(logicalExp," and ")
+        if eval(tempExp[0])==True:
+            self.update_logical_exp(tree.thenExpression, logicalExp, obj)
+        else:
+            self.update_logical_exp(tree.elseCondition, logicalExp, obj)
+
+        pass
+    def handleOCLIsTypeOf(self, tree,obj,logicalExp):
+        """The handleOCLIsTypeOf function handles the OCLIsTypeOf construct.
+
+        Args:
+                tree: Tree that is constructed using OCL Parser
+                obj: one object from object model
+                logicalExp: Expression to evaluate at the end to get the result
+        """
+        if isinstance(tree.source, Property):
+            sourceType = tree.source.type.name
+            self.checkAndAdd(logicalExp, " and ")
+            for index in range(len(tree.arguments)):
+                arg = tree.arguments[index].name
+                if arg == "String":
+                    logicalExp[0] = logicalExp[0] + '\"' + sourceType + '\"' + " =  \"str\""
+                elif arg == "Integer":
+                    logicalExp[0] = logicalExp[0] + '\"' + sourceType + '\"' + " =  \"int\""
+                elif arg == "Boolean":
+                    logicalExp[0] = logicalExp[0] + '\"' + sourceType + '\"' + " =  \"bool\""
+                elif arg == "Real":
+                    logicalExp[0] = logicalExp[0] + '\"' + sourceType + '\"' + " =  \"float\""
+                if index >0 and index < len(tree.arguments)-1:
+                    self.checkAndAdd(logicalExp, "and")
+
+
+    def update_logical_exp(self, tree, logicalExp, obj):
+        """The update_logical_exp function updates the logical expression.
+
+        Args:
+                        tree: Tree that is constructed using OCL Parser
+                        obj: one object from object model
+                        logicalExp: Expression to evaluate at the end to get the result
+        """
+
+        if isinstance(tree,PropertyCallExpression):
+           if tree.source == None:
+                pass
+
+        if isinstance(tree, LoopExp):#forAll, select,..etc
+           source = tree.source
+           if obj.classifier.name == self.roothandler.get_context_name():
+                self.verifyBody(tree,obj,logicalExp,source)
+        if isinstance(tree, IfExp):
+            self.handleIFExp(tree, obj, logicalExp)
+        if isinstance(tree, OperationCallExpression):
+
+            if tree.name == "EXCLUDES":
+                self.handleExcludes(tree, obj, logicalExp)
+            elif tree.name == "INCLUDES":
+                self.handleIncludes(tree, obj, logicalExp)
+            elif tree.name == "Size":
+                self.handleSize(tree,obj,logicalExp)
+                self.checkAndAdd(logicalExp, " and ")
+            elif tree.name == "OCLISTYPEOF":
+                self.handleOCLIsTypeOf(tree,obj,logicalExp)
+            elif tree.name == "ALLInstances":
+                pass #handled elsewhere
+            else:
+                args = tree.arguments
+                for arg in args:
+                   if hasattr(arg,'name'):
+                       if isinstance(arg,IntegerLiteralExpression) or isinstance(arg,RealLiteralExpression) or isinstance(arg,BooleanLiteralExpression):
+                           logicalExp[0] = logicalExp[0] + str(arg.value)
+                       elif (isinstance(arg,StringLiteralExpression)):
+                           logicalExp[0] = logicalExp[0] + '"'+str(arg.value)+'"'
+                       else:
+                            logicalExp[0]= logicalExp[0] + str(self.get_value(arg.name,obj))
+                   else:
+                       if str(arg).lower() == "and" or str(arg).lower() =='or':
+                           self.checkAndAdd(logicalExp[0],str(arg))
+                       else:
+                           logicalExp[0] = logicalExp[0] +" " +str(arg)+ " "
+                if tree.referredOperation is not None  and( tree.referredOperation.get_infix_operator() == "and" or tree.referredOperation.get_infix_operator() == "or"):
+                    self.checkAndAdd(logicalExp[0],tree.referredOperation.get_infix_operator())
+        if hasattr(tree, "source"):
+            if tree.source is not None:
+                self.update_logical_exp(tree.source, logicalExp, obj)
+    def checkAndAdd(self, logicalExpTemplate, toAdd):
+        """The checkAndAdd function checks and updates the logical expression.
+
+        Args:
+                toAdd: item to add in the logical expression
+                logicalExpTemplate: Expression to evaluate at the end to get the result
+        """
+        if len(logicalExpTemplate[0])>5:
+            if toAdd == " and ":
+                if logicalExpTemplate[0][-5:] != " and ":
+                    logicalExpTemplate[0] = logicalExpTemplate[0]+toAdd
+        elif toAdd == " and ":
+            if len(logicalExpTemplate[0]) > 0 and len(logicalExpTemplate[0])<=5:
+                logicalExpTemplate[0] = logicalExpTemplate[0] + toAdd
+
+        if len(logicalExpTemplate[0]) > 4:
+            if toAdd == " or ":
+                if logicalExpTemplate[0][-4:] != " or ":
+                    logicalExpTemplate[0] = logicalExpTemplate[0] + toAdd
+
+    def valid_object(self,contextName, object):
+        """the valid_object verifies if the current object is the one constraint is applied on
+
+        Args:
+            contextName: name of the context of OCL constraint
+            Object: Object from object model to check
+
+        """
+        idSlot = self.getID(object.slots)
+        if idSlot.get_attribute.name == contextName:
+            return True
+        return False
+    def getValidObjects(self,contextName, objs):
+        """the getValidObjects returns all the objects the constraint should be applied on
+
+        Args:
+            contextName: name of the context of OCL constraint
+            objs: all objects from object model
+
+        """
+
+        toRet = []
+        for obj in objs.instances:
+            # if self.valid_object(contextName,obj):
+            if obj.classifier.name == contextName:
+                toRet.append(obj)
+        return toRet
+
+    def preprocessLogicalExp(self,exp):
+        """the preprocessLogicalExp function preprocesses before evaluating to correct the syntax.
+
+        Args:
+            exp: logical expression to be evaluated
+
+        """
+        exp[0]=exp[0].replace(' = ', ' == ').replace('<>', ' != ')
+        if len(exp[0])>5:
+            if exp[0][-5:] == " and ":
+                exp[0] = exp[0][:-5]
+        if len(exp[0]) > 4:
+            if exp[0][-4:] == " or ":
+                exp[0] = exp[0][:-4]
+    def evaluate(self, rootHandler,objectModel):
+        """the evaluate function is the main function to be called for evaluating any contraint.
+
+        Args:
+            rootHandler: Object of class RootHandler that handles the tree
+            objectModel: Object Model from BUML models
+        """
+        self.om = objectModel
+        self.roothandler = rootHandler
+
+        objs = self.getValidObjects(self.roothandler.get_context_name(),self.om)
+        tree = rootHandler.get_root()
+        logicalExpTemplate= [""]
+        for i in range(len(objs)):
+            self.update_logical_exp(tree, logicalExpTemplate, objs[i])
+            if len(objs)>1 and i < len(objs) -1:
+                self.checkAndAdd(logicalExpTemplate," and ")
+
+
+        if self.debug:
+            print("Logical Expression")
+            print(logicalExpTemplate[0])
+        self.preprocessLogicalExp(logicalExpTemplate)
+        return eval(logicalExpTemplate[0])

bocl/OCLWrapper.py

@@ -0,0 +1,44 @@
+from bocl.Evaluator import  Evaluator
+from besser.BUML.notations.ocl.BOCLLexer import BOCLLexer
+from besser.BUML.notations.ocl.BOCLParser import BOCLParser
+from besser.BUML.notations.ocl.BOCLListener import BOCLListener
+from besser.BUML.notations.ocl.RootHandler import Root_Handler
+from antlr4 import *
+
+class OCLWrapper:
+    """The OCLWrapper class is the wrapper around the evaluator class to prepare the construct needed by evaluator.
+
+    Args:
+        dm: Domain model in BUML
+        om: object model in BUML
+    Attributes:
+        dm: Domain model in BUML
+        om: object model in BUML
+    """
+    def __init__(self,dm,om):
+        self.dm = dm
+        self.om = om
+
+
+    def evaluate(self,ocl):
+        """the evaluate function takes the OCL constraint and evaluate using evaluator
+        Args:
+            ocl: Object of OCL class that constaints the OCL expression and context class
+        """
+
+        # self.preprocess(ocl.expression)
+        input_stream = InputStream(ocl.expression)
+        rootHandler = Root_Handler(ocl,self.dm,self.om)
+        lexer = BOCLLexer(input_stream)
+        stream = CommonTokenStream(lexer)
+        parser = BOCLParser(stream)
+        tree = parser.oclFile()
+        listener = BOCLListener(rootHandler)
+        walker = ParseTreeWalker()
+        walker.walk(listener,tree)
+
+        eval = Evaluator()
+
+        return eval.evaluate(rootHandler, self.om)
+
+        pass

bocl-0.1.0.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.1
+Name: bocl
+Version: 0.1.0
+Summary: BOCL
+Author: Luxembourg Institute of Science and Technology
+License: MIT
+Project-URL: Documentation, https://bocl-interpreter.readthedocs.io/en/latest/
+Project-URL: Source Code, https://github.com/BESSER-PEARL/BOCL-Interpreter
+Project-URL: Bug Tracker, https://github.com/BESSER-PEARL/BOCL-Interpreter/issues
+Keywords: uml,code generation,python
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: Arpeggio ==2.0.2
+Requires-Dist: colorama ==0.4.6
+Requires-Dist: iniconfig ==2.0.0
+Requires-Dist: packaging
+Requires-Dist: pluggy ==1.2.0
+Requires-Dist: pytest ==7.4.0
+Requires-Dist: setuptools ==68.2.2
+Requires-Dist: textX ==3.1.1
+Requires-Dist: jinja2 ==3.1.2
+Requires-Dist: antlr4-python3-runtime ==4.13.1
+Requires-Dist: requests ==2.31.0
+Requires-Dist: fastapi ==0.110.0
+Requires-Dist: pydantic ==2.6.3
+Requires-Dist: uvicorn ==0.28.0
+Requires-Dist: besser
+
+# BESSER Object Constraint Language Interpreter
+
+**BOCL** is a tool designed to parse and evaluate the OCL constraints designed on **BESSER** models.
+It is a python based implementation, that utilises parser and listener generated with the ANTLR4 grammer.
+
+**BESSER** is a low-modeling low-code open-source platform built on top 
+of our Python-based personal interpretation of a "Universal Modeling Language"
+
+## Basic Installation
+We have tested BOCL with python 3.9+. We recommend creating a virtual environment (e.g. `venv <https://docs.python.org/3/tutorial/venv.html>`_,
+`conda <https://docs.conda.io/en/latest/>`_).
+
+Dependencies
+************
+BOCL depends on BESSER for parsing the OCL constraints and providing a concrete syntax tree (CST) to evaluation. The latest stable version of BESSER is available in the Python Package Index (PyPi) and can be installed using
+
+
+    $ pip install besser
+
+
+# BOCL Installation
+
+
+Stable version of BOCL interpreter can be installed via
+
+    $ pip install bocl
+
+
+
+## Building From Source
+
+To obtain the full code, including examples and tests, you can clone the git repository.
+
+    $ git clone https://github.com/BESSER-PEARL/BOCL-Interpreter
+    $ cd BOCL-Interpreter
+
+To install the reqs please run the following commands in virtual environment (recommended)
+
+    $ pip install -r requirements.txt
+
+## Contributing
+
+We encourage contributions from the community and any comment is welcome!
+
+If you are interested in contributing to this project, please read the [CONTRIBUTING.md](CONTRIBUTING.md) file.
+
+## Code of Conduct
+
+At BESSER, our commitment is centered on establishing and maintaining development environments that are welcoming, inclusive, safe and free from all forms of harassment. All participants are expected to voluntarily respect and support our [Code of Conduct](CODE_OF_CONDUCT.md).
+
+## Governance
+
+The development of this project follows the governance rules described in the [GOVERNANCE.md](GOVERNANCE.md) document.
+
+## Contact
+You can reach us at: [info@besser-pearl.org](mailto:info@besser-pearl-org)
+
+Website: https://besser-pearl.github.io/teampage/
+
+## License
+
+This project is licensed under the [MIT](https://mit-license.org/) license.

bocl-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+bocl/Evaluator.py,sha256=RtkRAiQNBxf1yvpLEoPWPGrNJ8j3rxcPPjzQ2i3cnFE,20231
+bocl/OCLWrapper.py,sha256=wu2YsEca6LlmClXVaeBeS4oIElBFALROSyTXrFtjz0o,1462
+bocl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+models/library_object.py,sha256=kuKXMhhuWAiNqHxEXWMnJhMSJTwt2bT7rVDiG8FRCTU,10452
+models/researcher_object.py,sha256=cDpJdGu0hzmrhdZUF5dfO1P7UdjVNaBOiwilMVH8Rvk,8842
+bocl-0.1.0.dist-info/METADATA,sha256=3SAWHY0HP9uBgWPIMuf7CJK7xvBJFC7RTumBoVDZP68,3242
+bocl-0.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+bocl-0.1.0.dist-info/top_level.txt,sha256=d5ZFSziu4ds27nZoZcgWLHKMJsID-7w5M7grHxSYjoE,12
+bocl-0.1.0.dist-info/RECORD,,

bocl-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bocl-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+bocl
+models

models/library_object.py

@@ -0,0 +1,161 @@
+
+from besser.BUML.metamodel.structural import DomainModel, Class, Property, \
+    PrimitiveDataType, Multiplicity, BinaryAssociation,Constraint
+from besser.BUML.metamodel.object import *
+import datetime
+
+#############################################
+#   Library - structural model definition   #
+#############################################
+
+# Primitive DataTypes
+t_int: PrimitiveDataType = PrimitiveDataType("int")
+t_str: PrimitiveDataType = PrimitiveDataType("str")
+t_date: PrimitiveDataType = PrimitiveDataType("date")
+
+# Library attributes definition
+library_name: Property = Property(name="name", type=t_str)
+address: Property = Property(name="address", type=t_str)
+# Library class definition
+library: Class = Class (name="Library", attributes={library_name, address})
+
+# Book attributes definition
+title: Property = Property(name="title", type=t_str)
+pages: Property = Property(name="pages", type=t_int)
+release: Property = Property(name="release", type=t_date)
+# Book class definition
+book: Class = Class (name="Book", attributes={title, pages, release})
+
+# Author attributes definition
+author_name: Property = Property(name="name", type=t_str)
+email: Property = Property(name="email", type=t_str)
+# Author class definition
+author: Class = Class (name="Author", attributes={author_name, email})
+
+# Library-Book association definition
+located_in: Property = Property(name="locatedIn",type=library, multiplicity=Multiplicity(1, 1))
+has: Property = Property(name="has", type=book, multiplicity=Multiplicity(0, "*"))
+lib_book_association: BinaryAssociation = BinaryAssociation(name="lib_book_assoc", ends={located_in, has})
+
+# Book-Author association definition
+publishes: Property = Property(name="publishes", type=book, multiplicity=Multiplicity(0, "*"))
+writed_by: Property = Property(name="writedBy", type=author, multiplicity=Multiplicity(1, "*"))
+book_author_association: BinaryAssociation = BinaryAssociation(name="book_author_assoc", ends={writed_by, publishes})
+
+constraintPageNumber: Constraint = Constraint(name = "libraryPageNumber",context=library,expression="context Library inv inv1: self.has ->forAll(b:Book|b.pages>0)",language="OCL")
+
+constraintBookPageNumber: Constraint = Constraint(name = "BookPageNumber",context=book,expression="context Book inv inv2: self.pages>0",language="OCL")
+
+constraintTitleIncorrect: Constraint = Constraint(name = "BookTitleInc",context=book,expression="context Book inv inv2: self.title= 'NI')",language="OCL")
+
+constraintTitleCorrect: Constraint = Constraint(name = "BookTitle",context=book,expression="context Book inv inv2: self.title <> 'NI'",language="OCL")
+
+constraintLibraryExists: Constraint = Constraint(name = "LibarayExistsConst",context=library,expression="context Library inv inv3: self.has->exists( i_book : Book | i_book.pages <= 110 )",language="OCL")
+
+# constraintLibraryExclude: Constraint = Constraint(name = "LibarayExclude",context=library,expression="context Library inv inv3: self.has->excludes()",language="OCL")
+constraintLibrarySize: Constraint = Constraint(name = "LibaraySize",context=library,expression="context Library inv inv3: self.has->size()>1",language="OCL")
+
+constraintLibraryCollect: Constraint = Constraint(name = "LibaryCollect",context=library,
+expression="context Library inv inv3: self.has->collect(i_book : Book | i_book.pages <= 110)"
+           "->size()>0",language="OCL")
+
+constraintLibraryIf: Constraint = Constraint(name ="LibaryIf", context=library,
+expression="context Library inv inv3: if self.name <> 'NI' then self.has->exists"
+           "( i_book : Book | i_book.pages <= 110 ) else self.has->forAll(b:Book|b.pages>0)"
+           " endif", language="OCL")
+
+constraintLibraryElse: Constraint = Constraint(name ="LibaryElse", context=library,
+expression="context Library inv inv3: if self.name = 'NI' then self.has->exists"
+           "( i_book : Book | i_book.pages <= 110 ) else self.has->forAll(b:Book|b.pages>0)"
+           " endif", language="OCL")
+
+constraintLibraryElseFalse: Constraint = Constraint(name ="LibaryElseFalse", context=library, expression="context Library inv inv3: if self.name = 'NI' then self.has->exists( i_book : Book | i_book.pages <= 110 ) else self.has->forAll(b:Book|b.pages<0) endif", language="OCL")
+
+
+constraintNameOCLIsTypeOf: Constraint = Constraint(name ="BookIsTypeOfStr", context=book, expression="context Book inv inv3: self.title.oclIsTypeOf(String)", language="OCL")
+
+constraintNameOCLIsTypeOfInt: Constraint = Constraint(name ="BookIsTypeOfInt", context=book, expression="context Book inv inv3: self.pages.oclIsTypeOf(Integer)", language="OCL")
+
+constraintNameOCLIsTypeOfIntFalse: Constraint = Constraint(name ="BookIsTypeOfIntFalse", context=book, expression="context Book inv inv3: self.pages.oclIsTypeOf(String)", language="OCL")
+constraintifElseSize: Constraint = Constraint(name ="constraintifElseSize", context=library, expression="context Library inv inv3: if self.name <> 'NI' then self.has->exists( i_book : Book | i_book.pages <= 110 )->size()<3 else self.has->forAll(b:Book|b.pages>0) endif", language="OCL")
+
+
+# Domain model definition
+library_model : DomainModel = DomainModel(name="Library model", types={library, book, author}, 
+                                          associations={lib_book_association, book_author_association},
+                                          constraints={
+                                              constraintBookPageNumber,
+                                                       # constraintTitleIncorrect,
+                                                       constraintPageNumber,
+                                                       constraintTitleCorrect,
+                                                       constraintLibraryExists,
+                                                       constraintLibrarySize,
+                                                       constraintLibraryCollect,
+                                                       constraintLibraryIf,
+                                                       constraintLibraryElse,
+                                                       # constraintLibraryElseFalse,
+                                                       constraintNameOCLIsTypeOf,
+                                                       constraintNameOCLIsTypeOfInt,
+                                                       # constraintNameOCLIsTypeOfIntFalse
+                                          }
+
+                                            # constraints={constraintLibrarySize}
+                                          )
+
+
+#########################################
+#   Library - object model definition   #
+#########################################
+
+
+# Library object attributes
+library_obj_name: AttributeLink = AttributeLink(attribute=library_name, value=DataValue(classifier=t_str, value="Library test"))
+library_obj_address: AttributeLink = AttributeLink(attribute=address, value=DataValue(classifier=t_str, value="street 123"))
+# Library object
+library_obj: Object = Object(name="Library Object", classifier=library, slots=[library_obj_name, library_obj_address])
+
+# Book object attributes
+book_obj_name: AttributeLink = AttributeLink(attribute=title, value=DataValue(classifier=t_str, value="Book tittle"))
+book_obj_pages: AttributeLink = AttributeLink(attribute=pages, value=DataValue(classifier=t_int, value=100))
+book_obj_release: AttributeLink = AttributeLink(attribute=release, value=DataValue(classifier=t_date, value=datetime.datetime(2020, 3, 15)))
+# Book object
+book_obj: Object = Object(name="Book Object", classifier=book, slots=[book_obj_name, book_obj_pages])
+
+# Book_2 object attributes
+
+book_obj_name_2: AttributeLink = AttributeLink(attribute=title, value=DataValue(classifier=t_str, value="Book tittle_2"))
+book_obj_pages_2: AttributeLink = AttributeLink(attribute=pages, value=DataValue(classifier=t_int, value=400))
+book_obj_release_2: AttributeLink = AttributeLink(attribute=release, value=DataValue(classifier=t_date, value=datetime.datetime(2024, 3, 15)))
+# Book object
+book_obj_2: Object = Object(name="Book 2 Object", classifier=book, slots=[book_obj_name_2, book_obj_pages_2])
+
+# Author object attributes
+author_obj_name: AttributeLink = AttributeLink(attribute=author_name, value=DataValue(classifier=t_str, value="John Doe"))
+author_obj_email: AttributeLink = AttributeLink(attribute=email, value=DataValue(classifier=t_str, value="john@doe.com"))
+# Author object
+author_obj: Object = Object(name="Author Object", classifier=author, slots=[author_obj_name, author_obj_email])
+
+# Book object and Author object link
+book_link_end1: LinkEnd = LinkEnd(name="book_end1", association_end=publishes, object=book_obj)
+author_link_end: LinkEnd = LinkEnd(name="author_end", association_end=writed_by, object=author_obj)
+author_book_link: Link = Link(name="author_book_link", association=book_author_association, connections=[book_link_end1,author_link_end])
+
+# Book Library and Book object link
+book_link_end2: LinkEnd = LinkEnd(name="book_end2", association_end=has, object=book_obj)
+library_link_end: LinkEnd = LinkEnd(name="library_end", association_end=located_in, object=library_obj)
+library_book_link: Link = Link(name="library_book_link", association=book_author_association, connections=[book_link_end2,library_link_end])
+
+# Book object and Author object link
+book_link_end2: LinkEnd = LinkEnd(name="book_end3", association_end=publishes, object=book_obj_2)
+author_link_end2: LinkEnd = LinkEnd(name="author_end2", association_end=writed_by, object=author_obj)
+author_book_link2: Link = Link(name="author_book_link2", association=book_author_association, connections=[book_link_end2,author_link_end2])
+
+# Book Library and Book object link
+book_link_end3: LinkEnd = LinkEnd(name="book_end4", association_end=has, object=book_obj_2)
+library_link_end3: LinkEnd = LinkEnd(name="library_end3", association_end=located_in, object=library_obj)
+library_book_link3: Link = Link(name="library_book_link3", association=book_author_association, connections=[book_link_end3,library_link_end3])
+
+
+
+# Object model definition
+object_model: ObjectModel = ObjectModel(name="Object model", instances={library_obj, author_obj, book_obj,book_obj_2}, links={author_book_link, library_book_link,author_book_link2,library_book_link3})

models/researcher_object.py

@@ -0,0 +1,136 @@
+from besser.BUML.metamodel.structural import *
+from besser.BUML.metamodel.object import *
+
+#########################################
+#           Structural Model            #
+#########################################
+
+# Primitive DataTypes
+t_int: PrimitiveDataType = PrimitiveDataType("int")
+t_str: PrimitiveDataType = PrimitiveDataType("str")
+t_bool: PrimitiveDataType = PrimitiveDataType("bool")
+
+# Paper class
+tittle: Property = Property(name="tittle", type=t_str)
+wordCount: Property = Property(name="wordcount", type=t_int)
+studentPaper: Property = Property(name="studentPaper", type=t_bool)
+paper: Class = Class(name="Paper", attributes={tittle, wordCount, studentPaper})
+
+# Researcher class
+name: Property = Property(name="name", type=t_str)
+isStudent: Property = Property(name="isStudent", type=t_bool)
+researcher: Class = Class(name="Researcher", attributes={name, isStudent})
+
+# paper-researcher association
+manuscript: Property = Property(name="manuscript", type=paper, multiplicity=Multiplicity(1, 1))
+author: Property = Property(name="author", type=researcher, multiplicity=Multiplicity(1, 2))
+writes: BinaryAssociation = BinaryAssociation(name="writes", ends={manuscript, author})
+
+# researcher-paper association
+submission: Property = Property(name="submission", type=paper, multiplicity=Multiplicity(1, 1))
+referee: Property = Property(name="referee", type=researcher, multiplicity=Multiplicity(3, 3))
+reviews: BinaryAssociation = BinaryAssociation(name="reviews", ends={submission, referee})
+
+constraintResearcher: Constraint = Constraint(name="NoSelfReviews", context=researcher,
+                                               expression="context Researcher inv NoSelfReviews: self.submission->excludes(self.manuscript)", language="OCL")
+
+constraintPaper: Constraint = Constraint(name="PaperLength", context=paper,
+                                               expression="context Paper inv :self.wordcount < 10000", language="OCL")
+
+constraintAuthorsOfStudentPaper: Constraint = Constraint(name="AuthorsOfStudentPaper", context=paper,
+                                               expression="context Paper inv AuthorsOfStudentPaper: self.author->exists(x:Researcher | x.isStudent =True)", language="OCL")
+
+constraintNoStudentReviewers: Constraint = Constraint(name="NoStudentReviewers", context=paper,
+                                               expression="context Paper inv NoStudentReviewers:self.referee->forAll(r:Researcher | r.isStudent =False)", language="OCL")
+
+constraintLimitsOnStudentPapers: Constraint = Constraint(name="LimitsOnStudentPapers", context=paper,
+                                               expression="context Paper inv LimitsOnStudentPapers: Paper::allInstances()->exists(p:Paper | p.studentPaper = True) and Paper::allInstances()->select(p:Paper | p.studentPaper=True) ->size() < 5", language="OCL")
+
+constraintPaperTitle: Constraint = Constraint(name="constraintPaperTitle", context=paper,
+                                               expression="context Paper inv title: self.tittle<> 'test'", language="OCL")
+constraintResearcherName:Constraint = Constraint(name="consResearcherName", context=researcher,
+                                               expression="context Researcher inv title: self.name<> 'test'", language="OCL")
+
+constraintPaperWordCountgreater: Constraint = Constraint(name="PaperLength100", context=paper,
+                                               expression="context Paper inv :self.wordcount > 1000", language="OCL")
+
+
+# Structural model
+domain_model: DomainModel = DomainModel(name="my_model", types={paper, researcher}, associations={writes, reviews}, constraints = {
+                                                                                                                    constraintResearcher,
+                                                                                                                    constraintPaper,
+                                                                                                                    constraintAuthorsOfStudentPaper,
+                                                                                                                    constraintNoStudentReviewers,
+                                                                                                                    constraintLimitsOnStudentPapers,
+                                                                                                                    constraintPaperTitle,
+                                                                                                                    constraintResearcherName,
+                                                                                                                    constraintPaperWordCountgreater
+                                                                                                                                   })
+
+
+###################################
+#          Object model           #
+###################################
+
+# paper object
+paper_name: AttributeLink = AttributeLink(value=DataValue(value="besser lowcode platform", classifier=None), attribute=tittle)
+paper_words: AttributeLink = AttributeLink(value=DataValue(value=5000, classifier=None), attribute=wordCount)
+paper_student_paper: AttributeLink = AttributeLink(value=DataValue(value=True, classifier=None), attribute=studentPaper)
+paper_obj: Object = Object(name="besser paper", classifier=paper, slots=[paper_name, paper_words, paper_student_paper])
+
+# researcher 1 object
+r1_name: AttributeLink = AttributeLink(value=DataValue(value="Marc", classifier=None), attribute=name)
+r1_is_student: AttributeLink = AttributeLink(value=DataValue(value=True, classifier=None), attribute=isStudent)
+researcher_1: Object = Object(name="Marc researcher", classifier=researcher, slots=[r1_name, r1_is_student])
+
+# researcher 2 object
+r2_name: AttributeLink = AttributeLink(value=DataValue(value="James", classifier=None), attribute=name)
+r2_is_student: AttributeLink = AttributeLink(value=DataValue(value=True, classifier=None), attribute=isStudent)
+researcher_2: Object = Object(name="James researcher", classifier=researcher, slots=[r2_name, r2_is_student])
+
+# researcher 3 object
+r3_name: AttributeLink = AttributeLink(value=DataValue(value="Adam", classifier=None), attribute=name)
+r3_is_student: AttributeLink = AttributeLink(value=DataValue(value=False, classifier=None), attribute=isStudent)
+researcher_3: Object = Object(name="Adam researcher", classifier=researcher, slots=[r3_name, r3_is_student])
+
+# researcher 4 object
+r4_name: AttributeLink = AttributeLink(value=DataValue(value="Lola", classifier=None), attribute=name)
+r4_is_student: AttributeLink = AttributeLink(value=DataValue(value=False, classifier=None), attribute=isStudent)
+researcher_4: Object = Object(name="Lola researcher", classifier=researcher, slots=[r4_name, r4_is_student])
+
+# researcher 5 object
+r5_name: AttributeLink = AttributeLink(value=DataValue(value="Sarah", classifier=None), attribute=name)
+r5_is_student: AttributeLink = AttributeLink(value=DataValue(value=False, classifier=None), attribute=isStudent)
+researcher_5: Object = Object(name="Sarah researcher", classifier=researcher, slots=[r5_name, r5_is_student])
+
+# Links definition
+writes_1: Link = Link(name="writes", association=writes, connections=[
+    LinkEnd(name="manuscript", association_end=manuscript, object=paper_obj),
+    LinkEnd(name="author", association_end=author, object=researcher_1)
+])
+
+writes_2: Link = Link(name="writes", association=writes, connections=[
+    LinkEnd(name="researcher", association_end=manuscript, object=paper_obj),
+    LinkEnd(name="author", association_end=author, object=researcher_2)
+])
+
+reviews_1: Link = Link(name="writes", association=writes, connections=[
+    LinkEnd(name="submission", association_end=submission, object=paper_obj),
+    LinkEnd(name="referee", association_end=referee, object=researcher_3)
+])
+
+reviews_2: Link = Link(name="writes", association=writes, connections=[
+    LinkEnd(name="submission", association_end=submission, object=paper_obj),
+    LinkEnd(name="referee", association_end=referee, object=researcher_4)
+])
+
+reviews_3: Link = Link(name="writes", association=writes, connections=[
+    LinkEnd(name="submission", association_end=submission, object=paper_obj),
+    LinkEnd(name="referee", association_end=referee, object=researcher_5)
+])
+
+
+
+# object model
+object_model: ObjectModel = ObjectModel(name="Object_model", instances={paper_obj, researcher_1, researcher_2, researcher_3, researcher_4, researcher_5},
+                                        links={writes_1, writes_2, reviews_1, reviews_2, reviews_3})