bocl 0.2.0__tar.gz

bocl-0.2.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.1
+Name: bocl
+Version: 0.2.0
+Summary: B-OCL
+Author: Luxembourg Institute of Science and Technology
+License: MIT
+Project-URL: Documentation, https://b-ocl-interpreter.readthedocs.io/en/latest/
+Project-URL: Source Code, https://github.com/BESSER-PEARL/B-OCL-Interpreter
+Project-URL: Bug Tracker, https://github.com/BESSER-PEARL/B-OCL-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
+
+**B-OCL** 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 B-OCL with python 3.9+. We recommend creating a virtual environment using `venv <https://docs.python.org/3/tutorial/venv.html>`_, or
+`conda <https://docs.conda.io/en/latest/>`_).
+
+Dependencies
+************
+B-OCL depends on BESSER for parsing the OCL constraints and providing a concrete syntax tree (CST) to evaluate. The latest stable version of BESSER is available in the Python Package Index (PyPi) and can be installed using
+
+
+    $ pip install besser
+
+
+# B-OCL Installation
+
+
+Stable version of B-OCL 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/b-ocl-Interpreter
+    $ cd b-ocl-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/website/
+
+## Documentation
+More details about B-OCL can be found here https://b-ocl-interpreter.readthedocs.io/en/latest/
+
+## License
+
+This project is licensed under the [MIT](https://mit-license.org/) license.

bocl-0.2.0/README.md

@@ -0,0 +1,63 @@
+# BESSER Object Constraint Language Interpreter
+
+**B-OCL** 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 B-OCL with python 3.9+. We recommend creating a virtual environment using `venv <https://docs.python.org/3/tutorial/venv.html>`_, or
+`conda <https://docs.conda.io/en/latest/>`_).
+
+Dependencies
+************
+B-OCL depends on BESSER for parsing the OCL constraints and providing a concrete syntax tree (CST) to evaluate. The latest stable version of BESSER is available in the Python Package Index (PyPi) and can be installed using
+
+
+    $ pip install besser
+
+
+# B-OCL Installation
+
+
+Stable version of B-OCL 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/b-ocl-Interpreter
+    $ cd b-ocl-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/website/
+
+## Documentation
+More details about B-OCL can be found here https://b-ocl-interpreter.readthedocs.io/en/latest/
+
+## License
+
+This project is licensed under the [MIT](https://mit-license.org/) license.

bocl-0.2.0/bocl/OCLWrapper.py

@@ -0,0 +1,46 @@
+"""Including imports from BESSER and ANTLR4"""
+from antlr4 import InputStream,CommonTokenStream,ParseTreeWalker
+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 bocl.evaluator import Evaluator
+
+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 __str__(self):
+        return str(self.dm)+ str(self.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)
+        root_handler = Root_Handler(ocl,self.dm,self.om)
+        lexer = BOCLLexer(input_stream)
+        stream = CommonTokenStream(lexer)
+        parser = BOCLParser(stream)
+        tree = parser.oclFile()
+        listener = BOCLListener(root_handler)
+        walker = ParseTreeWalker()
+        walker.walk(listener,tree)
+
+        evalualor = Evaluator()
+
+        return evalualor.evaluate(root_handler, self.om)

bocl-0.2.0/bocl/evaluator.py

@@ -0,0 +1,486 @@
+"""Importing OCL from main BESSER repository"""
+from besser.BUML.metamodel.ocl.ocl 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.all_obj_sat = []
+        self.om = None
+        self.root_handler = None
+
+    def get_value(self, name, obj):
+        """The get_value function to retrieve value of attribute from class_object.
+
+            Args:
+                        name: name of the attribute
+                        obj: Object from object model
+            """
+        for slot in obj.slots:
+            if name == slot.attribute.name:
+                if slot.attribute.type.name == 'str':
+                    return '"' + slot.value.value + '"'
+                return slot.value.value
+        return None
+
+    def check_in_obj(self, obj, source):
+        """The check_in_obj function identifies the class_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
+        return None
+
+    def check_in_link_ends(self, obj, source):
+        """The check_in_link_ends 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
+        """
+        to_ret = []
+        for link in obj.links:
+            for connection in link.connections:
+                if connection.association_end.name == source.name:
+                    to_ret.append(connection.object)
+
+        return to_ret
+
+    def handle_for_all(self, tree, all_objs, logical_exp):
+        """The handle_for_all function handles forAll expression from OCL MM.
+
+        Args:
+                    tree: Tree that is constructed using OCL Parser
+                    all_objs: all objects from object model
+                    logical_exp: Expression to evaluate at the end to get the result
+        """
+        logical_exp[0] = logical_exp[0] + " ("
+        for index in range(len(all_objs)):
+            if len(tree.get_body) > 0:
+                self.update_logical_exp(tree.get_body[0], logical_exp, all_objs[index])
+                if index < len(all_objs) - 1:
+                    logical_exp[0] = logical_exp[0] + " and "
+        logical_exp[0] = logical_exp[0] + " )"
+
+    def handle(self, source, obj, logical_exp, right_side=False):
+        """The handle function handles Property Call expression from OCL MM.
+
+        Args:
+                    source: one child in OCL CST
+                    obj: one object from object model
+                    logical_exp: Expression to evaluate at the end to get the result
+                    right_side: to identify the side of logical expression
+        """
+
+        if isinstance(source, (PropertyCallExpression,Property)):
+            # if len(source.name.split('.'))==2:
+            all_objs = self.check_in_obj(obj, source)
+            if all_objs is None:
+                all_objs = self.check_in_link_ends(obj, source)
+            for index in range(len(all_objs)):
+                objs = all_objs[index]
+                if len(all_objs) > 1 or right_side:
+                    logical_exp[0] = logical_exp[0] + " [ "
+                for i in range(len(objs.slots)):
+                    logical_exp[0] = logical_exp[0] + "\"" + str(objs.slots[i].attribute.name) + str(
+                        objs.slots[i].value.value) + "\""
+                    if i < len(objs.slots) - 1:
+                        logical_exp[0] = logical_exp[0] + ","
+                if not right_side:
+                    if len(all_objs) > 1 and index < len(all_objs) - 1:
+                        logical_exp[0] = logical_exp[0] + " ], "
+                else:
+                    logical_exp[0] = logical_exp[0] + " ] "
+                    if len(all_objs) > 1 and index < len(all_objs) - 1:
+                        logical_exp[0] = logical_exp[0] + " , "
+
+
+
+
+    def handle_excludes(self, tree, obj, logical_exp):
+        """The handle_excludes function handles excludes construct.
+
+        Args:
+                    tree: Tree that is constructed using OCL Parser
+                    obj: one object from object model
+                    logical_exp: Expression to evaluate at the end to get the result
+        """
+        # tempLogicalExp =[""]
+        args = tree.arguments
+        self.check_and_add(logical_exp, " and ")
+        logical_exp[0] = logical_exp[0] + " [ "
+        self.handle(tree.source, obj, logical_exp)
+        logical_exp[0] = logical_exp[0] + " ] not in "
+        if len(args) == 1:  # Property
+            logical_exp[0] = logical_exp[0] + " [ "
+            self.handle(args[0], obj, logical_exp, True)
+            logical_exp[0] = logical_exp[0] + " ]"
+
+
+    def handle_includes(self, tree, obj, logical_exp):
+        """The handle_includes function handles includes construct.
+
+        Args:
+                    tree: Tree that is constructed using OCL Parser
+                    obj: one object from object model
+                    logical_exp: Expression to evaluate at the end to get the result
+        """
+
+        # tempLogicalExp =[""]
+        args = tree.arguments
+        self.check_and_add(logical_exp, " and ")
+        logical_exp[0] = logical_exp[0] + " [ "
+        self.handle(tree.source, obj, logical_exp)
+        logical_exp[0] = logical_exp[0] + " ] in "
+        if len(args) == 1:  # Property
+            logical_exp[0] = logical_exp[0] + " [ "
+            self.handle(args[0], obj, logical_exp, True)
+            logical_exp[0] = logical_exp[0] + " ]"
+
+
+    def handle_exists(self, tree, all_objs, logical_exp):
+        """The handle_exists function handles exists construct.
+
+        Args:
+            tree: Tree that is constructed using OCL Parser
+            all_objs: all objects from object model
+            logical_exp: Expression to evaluate at the end to get the result
+        """
+        logical_exp[0] = logical_exp[0] + " ( "
+        temp = logical_exp[0]
+        for index in range(len(all_objs)):
+            if len(tree.get_body) > 0:
+                self.update_logical_exp(tree.get_body[0], logical_exp, all_objs[index])
+                if index < len(all_objs) - 1:
+                    logical_exp[0] = logical_exp[0] + " or "
+        if temp == logical_exp[0]:
+            logical_exp[0] = logical_exp[0] + " False "
+
+        logical_exp[0] = logical_exp[0] + " )"
+
+    def handle_select(self, tree, all_objs):
+        """The handle_select function handles select construct.
+
+        Args:
+               tree: Tree that is constructed using OCL Parser
+               all_objs: all objects from object model
+        """
+        self.all_obj_sat.append([])
+        for obj in all_objs:
+            expression = [""]
+            if len(tree.get_body) > 0:
+                self.update_logical_exp(tree.get_body[0], expression, obj)
+                self.preprocess_logical_exp(expression)
+                if eval(expression[0]) is True:
+                    self.all_obj_sat[-1].append(obj)
+
+    def handle_collect(self, tree, all_objs):
+        """The handle_collect function handles collect construct.
+
+        Args:
+               tree: Tree that is constructed using OCL Parser
+               all_objs: all objects from object model
+        """
+        self.all_obj_sat.append([])
+        for obj in all_objs:
+            expression = [""]
+            if len(tree.get_body) > 0:
+                self.update_logical_exp(tree.get_body[0], expression, obj)
+                self.preprocess_logical_exp(expression)
+                if eval(expression[0]) is True:
+                    self.all_obj_sat[-1].append(obj)
+
+    def verify_body(self, tree, obj, logical_exp, source, all_objs = None):
+        """The verify_body 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
+            logical_exp: Expression to evaluate at the end to get the result
+            source: source of the obj in CSTree
+        """
+        expression_type = tree.name
+        if all_objs is None:
+            all_objs = self.check_in_obj(obj, source)
+            if all_objs is None:
+                all_objs = self.check_in_link_ends(obj, source)
+        if source.name == "ALLInstances":
+            class_name = source.source.name
+            all_objs = self.get_valid_objects(class_name, self.om)
+
+        if expression_type == "forAll":
+            self.handle_for_all(tree, all_objs, logical_exp)
+        elif expression_type == "exists":
+            self.handle_exists(tree, all_objs, logical_exp)
+        elif expression_type == "collect":
+            self.handle_collect(tree, all_objs)
+        elif expression_type == "select":
+            self.handle_select(tree, all_objs)
+
+
+    def get_id(self, slots):
+        """The get_id 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
+        return None
+
+    def add_to_exp(self, item, logical_exp):
+        """The add_to_exp function adds the item to logicalExpression.
+
+        Args:
+              item: item to add in Logical Expression
+              logical_exp: logical Expression
+        """
+        if logical_exp[0] == "":
+            logical_exp[0] = logical_exp[0] + item
+        else:
+            logical_exp[0] = logical_exp[0] + " and " + item
+
+    def handle_size(self, tree, obj, logical_exp):
+        """The handle_size function handles the size construct.
+
+        Args:
+                    tree: Tree that is constructed using OCL Parser
+                    obj: one object from object model
+                    logical_exp: Expression to evaluate at the end to get the result
+        """
+        self.check_and_add(logical_exp, " and ")
+        logical_exp[0] = logical_exp[0] + "("
+        if isinstance(tree.source, Property):
+            all_objs = self.check_in_obj(obj, tree.source)
+            if all_objs is None:
+                all_objs = self.check_in_link_ends(obj, tree.source)
+            logical_exp[0] = logical_exp[0] + str(len(all_objs))
+            for arg in tree.arguments:
+                if isinstance(arg, (IntegerLiteralExpression, RealLiteralExpression, BooleanLiteralExpression)):
+                    logical_exp[0] = logical_exp[0] + str(arg.value)
+                else:
+                    logical_exp[0] = logical_exp[0] + str(arg)
+        elif isinstance(tree.source, LoopExp):
+            source = None
+            if tree.source.source is not None:
+                source = tree.source.source
+            if source is not None and source.name == "ALLInstances":
+                class_name = source.source.name
+                all_objs = self.get_valid_objects(class_name, self.om)
+            else:
+                all_objs = self.check_in_obj(obj, source)
+                if all_objs is None:
+                    all_objs = self.check_in_link_ends(obj, source)
+            self.handle_collect(tree.source, all_objs)
+            if len(self.all_obj_sat) > 0:
+                logical_exp[0] = logical_exp[0] + str(len(self.all_obj_sat[-1]))
+                self.all_obj_sat.pop()
+            for arg in tree.arguments:
+
+                if isinstance(arg, (IntegerLiteralExpression,RealLiteralExpression,BooleanLiteralExpression)):
+                    logical_exp[0] = logical_exp[0] + str(arg.value)
+                else:
+                    logical_exp[0] = logical_exp[0] + str(arg)
+        logical_exp[0] = logical_exp[0] + ")"
+
+    def handle_if_exp(self, tree, obj, logical_exp):
+        """The handle_if_exp function handles the If construct.
+
+        Args:
+                    tree: Tree that is constructed using OCL Parser
+                    obj: one object from object model
+                    logical_exp: Expression to evaluate at the end to get the result
+        """
+
+        temp_exp = [""]
+        self.update_logical_exp(tree.ifCondition, temp_exp, obj)
+        self.preprocess_logical_exp(temp_exp)
+        self.check_and_add(logical_exp, " and ")
+        if eval(temp_exp[0]) is True:
+            self.update_logical_exp(tree.thenExpression, logical_exp, obj)
+        else:
+            self.update_logical_exp(tree.elseCondition, logical_exp, obj)
+
+
+
+    def handle_ocl_is_type_of(self, tree,  logical_exp):
+        """The handle_ocl_is_type_of function handles the OCLIsTypeOf construct.
+
+        Args:
+                tree: Tree that is constructed using OCL Parser
+                obj: one object from object model
+                logical_exp: Expression to evaluate at the end to get the result
+        """
+        if isinstance(tree.source, Property):
+            source_type = tree.source.type.name
+            self.check_and_add(logical_exp, " and ")
+            for index in range(len(tree.arguments)):
+                arg = tree.arguments[index].name
+                if arg == "String":
+                    logical_exp[0] = logical_exp[0] + '\"' + source_type + '\"' + " =  \"str\""
+                elif arg == "Integer":
+                    logical_exp[0] = logical_exp[0] + '\"' + source_type + '\"' + " =  \"int\""
+                elif arg == "Boolean":
+                    logical_exp[0] = logical_exp[0] + '\"' + source_type + '\"' + " =  \"bool\""
+                elif arg == "Real":
+                    logical_exp[0] = logical_exp[0] + '\"' + source_type + '\"' + " =  \"float\""
+                if index > 0 and index < len(tree.arguments) - 1:
+                    self.check_and_add(logical_exp, "and")
+
+    def update_logical_exp(self, tree, logical_exp, 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
+                        logical_exp: Expression to evaluate at the end to get the result
+        """
+
+        if isinstance(tree, PropertyCallExpression):
+            if tree.source is None:
+                pass
+
+        if isinstance(tree, LoopExp):  # forAll, select,..etc
+            source = tree.source
+            if obj.classifier.name == self.root_handler.get_context_name():
+                self.verify_body(tree, obj, logical_exp, source)
+        if isinstance(tree, IfExp):
+            self.handle_if_exp(tree, obj, logical_exp)
+        if isinstance(tree, OperationCallExpression):
+
+            if tree.name == "EXCLUDES":
+                self.handle_excludes(tree, obj, logical_exp)
+            elif tree.name == "INCLUDES":
+                self.handle_includes(tree, obj, logical_exp)
+            elif tree.name == "Size":
+                self.handle_size(tree, obj, logical_exp)
+                self.check_and_add(logical_exp, " and ")
+            elif tree.name == "OCLISTYPEOF":
+                self.handle_ocl_is_type_of(tree,  logical_exp)
+            elif tree.name == "ALLInstances":
+                pass  # handled elsewhere
+            else:
+                args = tree.arguments
+                for arg in args:
+                    if hasattr(arg, 'name'):
+                        if isinstance(arg, (IntegerLiteralExpression, RealLiteralExpression, BooleanLiteralExpression)):
+                            logical_exp[0] = logical_exp[0] + str(arg.value)
+                        elif isinstance(arg, StringLiteralExpression):
+                            logical_exp[0] = logical_exp[0] + '"' + str(arg.value) + '"'
+                        else:
+                            logical_exp[0] = logical_exp[0] + str(self.get_value(arg.name, obj))
+                    else:
+                        if str(arg).lower() == "and" or str(arg).lower() == 'or':
+                            self.check_and_add(logical_exp[0], str(arg))
+                        else:
+                            logical_exp[0] = logical_exp[0] + " " + str(arg) + " "
+                if tree.referredOperation is not None and (
+                        tree.referredOperation.get_infix_operator() == "and" or tree.referredOperation.get_infix_operator() == "or"):
+                    self.check_and_add(logical_exp[0], tree.referredOperation.get_infix_operator())
+        if hasattr(tree, "source"):
+            if tree.source is not None:
+                self.update_logical_exp(tree.source, logical_exp, obj)
+
+    def check_and_add(self, logical_exp_template, to_add):
+        """The check_and_add function checks and updates the logical expression.
+
+        Args:
+                to_add: item to add in the logical expression
+                logical_exp_template: Expression to evaluate at the end to get the result
+        """
+        if len(logical_exp_template[0]) > 5:
+            if to_add == " and ":
+                if logical_exp_template[0][-5:] != " and ":
+                    logical_exp_template[0] = logical_exp_template[0] + to_add
+        elif to_add == " and ":
+            if len(logical_exp_template[0]) > 0 and len(logical_exp_template[0]) <= 5:
+                logical_exp_template[0] = logical_exp_template[0] + to_add
+
+        if len(logical_exp_template[0]) > 4:
+            if to_add == " or ":
+                if logical_exp_template[0][-4:] != " or ":
+                    logical_exp_template[0] = logical_exp_template[0] + to_add
+
+    def valid_object(self, context_name, class_object):
+        """the valid_object verifies if the current object is the one constraint is applied on
+
+        Args:
+            context_name: name of the context of OCL constraint
+            class_object: Object from object model to check
+
+        """
+        id_slot = self.get_id(class_object.slots)
+        if id_slot.get_attribute.name == context_name:
+            return True
+        return False
+
+    def get_valid_objects(self, context_name, objs):
+        """the get_valid_objects returns all the objects the constraint should be applied on
+
+        Args:
+            context_name: name of the context of OCL constraint
+            objs: all objects from object model
+
+        """
+
+        to_ret = []
+        for obj in objs.instances:
+            # if self.valid_object(context_name,obj):
+            if obj.classifier.name == context_name:
+                to_ret.append(obj)
+        return to_ret
+
+    def preprocess_logical_exp(self, exp):
+        """the preprocess_logical_exp 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, root_handler, object_model):
+        """the evaluate function is the main function to be called for evaluating any contraint.
+
+        Args:
+            root_handler: Object of class RootHandler that handles the tree
+            object_model: Object Model from BUML models
+        """
+        self.om = object_model
+        self.root_handler = root_handler
+
+        objs = self.get_valid_objects(self.root_handler.get_context_name(), self.om)
+        tree = root_handler.get_root()
+        logical_exp_template = [""]
+        for i in range(len(objs)):
+            self.update_logical_exp(tree, logical_exp_template, objs[i])
+            if len(objs) > 1 and i < len(objs) - 1:
+                self.check_and_add(logical_exp_template, " and ")
+
+        if self.debug:
+            print("Logical Expression")
+            print(logical_exp_template[0])
+        self.preprocess_logical_exp(logical_exp_template)
+        return eval(logical_exp_template[0])

bocl-0.2.0/bocl.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.1
+Name: bocl
+Version: 0.2.0
+Summary: B-OCL
+Author: Luxembourg Institute of Science and Technology
+License: MIT
+Project-URL: Documentation, https://b-ocl-interpreter.readthedocs.io/en/latest/
+Project-URL: Source Code, https://github.com/BESSER-PEARL/B-OCL-Interpreter
+Project-URL: Bug Tracker, https://github.com/BESSER-PEARL/B-OCL-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
+
+**B-OCL** 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 B-OCL with python 3.9+. We recommend creating a virtual environment using `venv <https://docs.python.org/3/tutorial/venv.html>`_, or
+`conda <https://docs.conda.io/en/latest/>`_).
+
+Dependencies
+************
+B-OCL depends on BESSER for parsing the OCL constraints and providing a concrete syntax tree (CST) to evaluate. The latest stable version of BESSER is available in the Python Package Index (PyPi) and can be installed using
+
+
+    $ pip install besser
+
+
+# B-OCL Installation
+
+
+Stable version of B-OCL 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/b-ocl-Interpreter
+    $ cd b-ocl-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/website/
+
+## Documentation
+More details about B-OCL can be found here https://b-ocl-interpreter.readthedocs.io/en/latest/
+
+## License
+
+This project is licensed under the [MIT](https://mit-license.org/) license.

bocl-0.2.0/bocl.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+requirements.txt
+setup.cfg
+bocl/OCLWrapper.py
+bocl/__init__.py
+bocl/evaluator.py
+bocl.egg-info/PKG-INFO
+bocl.egg-info/SOURCES.txt
+bocl.egg-info/dependency_links.txt
+bocl.egg-info/requires.txt
+bocl.egg-info/top_level.txt
+models/__init__.py
+models/library_object.py
+models/researcher_object.py
+models/team_player_object.py

bocl-0.2.0/bocl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bocl-0.2.0/bocl.egg-info/requires.txt

@@ -0,0 +1,15 @@
+Arpeggio==2.0.2
+colorama==0.4.6
+iniconfig==2.0.0
+packaging
+pluggy==1.2.0
+pytest==7.4.0
+setuptools==68.2.2
+textX==3.1.1
+jinja2==3.1.2
+antlr4-python3-runtime==4.13.1
+requests==2.31.0
+fastapi==0.110.0
+pydantic==2.6.3
+uvicorn==0.28.0
+besser

bocl-0.2.0/bocl.egg-info/top_level.txt

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

bocl-0.2.0/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})

bocl-0.2.0/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})

bocl-0.2.0/models/team_player_object.py

@@ -0,0 +1,95 @@
+
+from besser.BUML.metamodel.structural import DomainModel, Class, Property, \
+    PrimitiveDataType, Multiplicity, BinaryAssociation,Constraint
+from besser.BUML.metamodel.object import *
+import datetime
+
+#############################################
+#   Team Player - structural model definition   #
+#############################################
+
+# Primitive DataTypes
+t_int: PrimitiveDataType = PrimitiveDataType("int")
+t_str: PrimitiveDataType = PrimitiveDataType("str")
+t_date: PrimitiveDataType = PrimitiveDataType("date")
+
+# Team attributes definition
+team_name: Property = Property(name="name", type=t_str)
+team_city: Property = Property(name="city", type=t_str)
+team_division: Property = Property(name="division", type=t_str)
+# Team class definition
+team: Class = Class (name="team", attributes={team_name,team_city,team_division})
+
+# Player attributes definition
+name: Property = Property(name="name", type=t_str)
+age: Property = Property(name="age", type=t_int)
+position: Property = Property(name="position", type=t_str)
+jerseyNumber: Property = Property(name="jerseyNumber", type=t_int)
+
+# Player class definition
+player: Class = Class (name="player", attributes={name, age, position,jerseyNumber})
+
+
+# team-player association definition
+hasteam: Property = Property(name="many",type=team, multiplicity=Multiplicity(1, 1))
+many: Property = Property(name="has", type=player, multiplicity=Multiplicity(0, "*"))
+team_player_association: BinaryAssociation = BinaryAssociation(name="team_player_asso", ends={hasteam, many})
+
+
+constraintPlayerAge: Constraint = Constraint(name = "playerAge",context=player,expression="context player inv inv1: self.age > 10",language="OCL")
+
+constraintTeamCenter: Constraint = Constraint(name = "teamCenter",context=team,expression="context team inv inv2: self.many -> collect(p:player| p.position = 'center')->size()<3",language="OCL")
+
+# Domain model definition
+team_player_model : DomainModel = DomainModel(name="Team-Player model", types={team,player},
+                                          associations={team_player_association },
+                                          constraints={
+                                          constraintPlayerAge,
+                                          constraintTeamCenter
+                                          }
+                                          )
+
+
+#########################################
+#   TeamPlayer -  object model definition   #
+#########################################
+
+
+# Team  object attributes
+teamObjectName: AttributeLink = AttributeLink(attribute=team_name, value=DataValue(classifier=t_str, value="test-3"))
+teamcity: AttributeLink = AttributeLink(attribute=team_city, value=DataValue(classifier=t_str, value="not important"))
+teamDivision: AttributeLink = AttributeLink(attribute=team_division, value=DataValue(classifier=t_str, value="junior"))
+# Team  object
+teamObject: Object = Object(name="team  object", classifier=team, slots=[teamObjectName,teamcity,teamDivision])
+
+# player  object attributes
+player1_obj_name: AttributeLink = AttributeLink(attribute=name, value=DataValue(classifier=t_str, value="test"))
+player1_obj_age: AttributeLink = AttributeLink(attribute=age, value=DataValue(classifier=t_int, value=12))
+player1_obj_position: AttributeLink = AttributeLink(attribute=position, value=DataValue(classifier=t_str, value="center"))
+player1_obj_JN: AttributeLink = AttributeLink(attribute=jerseyNumber, value=DataValue(classifier=t_int, value=10))
+
+# Player  object
+player_1_obj: Object = Object(name="playerTest1", classifier=player, slots=[player1_obj_name, player1_obj_age,player1_obj_position,player1_obj_JN])
+
+
+# player 2  object attributes
+player2_obj_name: AttributeLink = AttributeLink(attribute=name, value=DataValue(classifier=t_str, value="test-2"))
+player2_obj_age: AttributeLink = AttributeLink(attribute=age, value=DataValue(classifier=t_int, value=15))
+player2_obj_position: AttributeLink = AttributeLink(attribute=position, value=DataValue(classifier=t_str, value="center"))
+player2_obj_JN: AttributeLink = AttributeLink(attribute=jerseyNumber, value=DataValue(classifier=t_int, value=11))
+
+# Player  object
+player_2_obj: Object = Object(name="playerTest2", classifier=player, slots=[player2_obj_name, player2_obj_age,player2_obj_position,player2_obj_JN])
+
+# player1 team  object link
+player_1_link_end: LinkEnd = LinkEnd(name="many", association_end=hasteam, object=player_1_obj)
+team_1_link_end: LinkEnd = LinkEnd(name="has", association_end=many, object=teamObject)
+team_player_link_1: Link = Link(name="team_player_link_1", association=team_player_association, connections=[player_1_link_end,team_1_link_end])
+
+# player2 team  object link
+player_2_link_end: LinkEnd = LinkEnd(name="many", association_end=hasteam, object=player_2_obj)
+team_2_link_end: LinkEnd = LinkEnd(name="has", association_end=many, object=teamObject)
+team_player_link_2: Link = Link(name="team_player_link_2", association=team_player_association, connections=[player_2_link_end,team_2_link_end])
+
+# Object model definition
+object_model: ObjectModel = ObjectModel(name="Object model", instances={teamObject, player_1_obj,player_2_obj}, links={team_player_link_1,team_player_link_2})

bocl-0.2.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

bocl-0.2.0/requirements.txt

@@ -0,0 +1,15 @@
+Arpeggio==2.0.2
+colorama==0.4.6
+iniconfig==2.0.0
+packaging
+pluggy==1.2.0
+pytest==7.4.0
+setuptools==68.2.2
+textX==3.1.1
+jinja2==3.1.2
+antlr4-python3-runtime==4.13.1
+requests==2.31.0
+fastapi==0.110.0
+pydantic==2.6.3
+uvicorn==0.28.0
+besser

bocl-0.2.0/setup.cfg

@@ -0,0 +1,27 @@
+[metadata]
+name = bocl
+version = 0.2.0
+author = Luxembourg Institute of Science and Technology
+description = B-OCL
+long_description = file: README.md
+long_description_content_type = text/markdown
+project_urls = 
+	Documentation = https://b-ocl-interpreter.readthedocs.io/en/latest/
+	Source Code = https://github.com/BESSER-PEARL/B-OCL-Interpreter
+	Bug Tracker = https://github.com/BESSER-PEARL/B-OCL-Interpreter/issues
+keywords = uml, code generation, python
+license = MIT
+license_files = LICENSE
+
+[options]
+python_requires = >=3.9
+install_requires = file: requirements.txt
+packages = find:
+
+[options.package_data]
+* = *.j2
+
+[egg_info]
+tag_build = 
+tag_date = 0
+