mps-cli 0.2.0__py3-none-any.whl

mps_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.3
+Name: mps-cli
+Version: 0.2.0
+Summary: MPS Command Line Interface (MPS-CLI) is a library to parse MPS files and build the model as Python objects.
+Project-URL: Homepage, https://github.com/mbeddr/mps-cli
+Project-URL: Bug Tracker, https://github.com/mbeddr/mps-cli/issues
+Author-email: Daniel Ratiu <ratiud@googlemail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: Eclipse Public License 2.0 (EPL-2.0)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+## MPS CLI Python Library
+
+This project provides a Python library which parses MPS files and builds the object model.
+
+### Features
+The following features are available:
+- load MPS files (*.mpsr, *.mps, *.jar) and expose their content as Python object model 
+  - solutions, models, root nodes, nodes, children, references, properties
+- extract the meta-information and expose it as Python object model
+  - list of languages, their concepts with information about properties, references, children
+
+The core of the Python object model is given by the following classes:
+- `SNode` - represents a node
+- `SModel` - represents a model
+- `SSolution` - represents a solution
+- `SRepository` - the repository containing the parsed model and meta-information
+
+### Limitations
+The plugin has currently the following limitations:
+- the recovered language information reflects only the used language in the loaded solutions
+
+### Run tests
+
+- `cd mps-cli-py`
+- `python -m unittest discover`

mps_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+mpscli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpscli/demo.py,sha256=JtEEvXlm80cuQkbch-ioahPi3nsBRgWErTGyOiia8-I,271
+mpscli/model/SConcept.py,sha256=mZYSaoRGUviBTu3dVcFIgFH1hNV3IKQOQFyCoALqie0,608
+mpscli/model/SLanguage.py,sha256=SomT_vsPtsbKK1oHVQ9ywadY5p6bLOcx8mEYDXHUdGk,283
+mpscli/model/SModel.py,sha256=9GvVb_Sqpc5v4o8UXfTT2bQTTeYW1IZMmX4jjSU56oE,641
+mpscli/model/SNode.py,sha256=09VkqEqk9OI0hLAVr7iq6if2xX7pRuxooHpHcJOoK-w,843
+mpscli/model/SNodeRef.py,sha256=nfd8ZLRwRmC9GnMQs9LX9oUUuzNOh4_4cqZu8BD682E,329
+mpscli/model/SRepository.py,sha256=trDtNvpQYandk2eciIR642CtRZh2JNalyqa0jgbTcf8,1640
+mpscli/model/SSolution.py,sha256=02I2J-SKQiKUvEWQ2PKGSN7DsEdz47N8YctKePGAq7U,170
+mpscli/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpscli/model/builder/NodeIdEncodingUtils.py,sha256=w_zcGDB_sqj8GcFZuPwS-JrLCscqH5fyUsJDKF6few0,852
+mpscli/model/builder/SLanguageBuilder.py,sha256=tkv6X74pX6jY8jI193JAKiYwCVookARsUzxthPMJhkg,1608
+mpscli/model/builder/SModelBuilderBase.py,sha256=JdowMDXkRq_nuYUUFghF5EfMWxA-dLOR7IZdpP40838,5043
+mpscli/model/builder/SModelBuilderDefaultPersistency.py,sha256=AefnHg-3AqLz0ilodM3FWIZfc6RLEYJIihKDKcxGEhY,623
+mpscli/model/builder/SModelBuilderFilePerRootPersistency.py,sha256=gcVq2D7j2nzpC_h_SG8CwQn9uILuL9rxTblo6IvPRdc,923
+mpscli/model/builder/SSolutionBuilder.py,sha256=bNldi9BYLPWCi_tIjCuWUvY1XjTs1ORgXMBP8bCTSGs,1544
+mpscli/model/builder/SSolutionsRepositoryBuilder.py,sha256=Phj_MMwcLHqIJKu7BIUY7FuHnWSH0ZT1_F4nfJDywwo,2040
+mpscli/model/builder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mps_cli-0.2.0.dist-info/METADATA,sha256=RwnUo2GdRYn3VrpD67T7Wy-9bWcQ1z88nAX-_p62eao,1577
+mps_cli-0.2.0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+mps_cli-0.2.0.dist-info/licenses/LICENSE,sha256=jDSfgHZNBkjmRfQe8jdypwyZWgkktSNfc19KPQnfEnw,14197
+mps_cli-0.2.0.dist-info/RECORD,,

mps_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.24.2
+Root-Is-Purelib: true
+Tag: py3-none-any

mps_cli-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,277 @@
+Eclipse Public License - v 2.0
+
+    THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+    PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+    OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+  a) in the case of the initial Contributor, the initial content
+     Distributed under this Agreement, and
+
+  b) in the case of each subsequent Contributor:
+     i) changes to the Program, and
+     ii) additions to the Program;
+  where such changes and/or additions to the Program originate from
+  and are Distributed by that particular Contributor. A Contribution
+  "originates" from a Contributor if it was added to the Program by
+  such Contributor itself or anyone acting on such Contributor's behalf.
+  Contributions do not include changes or additions to the Program that
+  are not Modified Works.
+
+"Contributor" means any person or entity that Distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which
+are necessarily infringed by the use or sale of its Contribution alone
+or when combined with the Program.
+
+"Program" means the Contributions Distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement
+or any Secondary License (as applicable), including Contributors.
+
+"Derivative Works" shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+"Modified Works" shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+"Distribute" means the acts of a) distributing or b) making available
+in any manner that enables the transfer of a copy.
+
+"Source Code" means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"Secondary License" means either the GNU General Public License,
+Version 2.0, or any later versions of that license, including any
+exceptions or additional permissions as identified by the initial
+Contributor.
+
+2. GRANT OF RIGHTS
+
+  a) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free copyright
+  license to reproduce, prepare Derivative Works of, publicly display,
+  publicly perform, Distribute and sublicense the Contribution of such
+  Contributor, if any, and such Derivative Works.
+
+  b) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free patent
+  license under Licensed Patents to make, use, sell, offer to sell,
+  import and otherwise transfer the Contribution of such Contributor,
+  if any, in Source Code or other form. This patent license shall
+  apply to the combination of the Contribution and the Program if, at
+  the time the Contribution is added by the Contributor, such addition
+  of the Contribution causes such combination to be covered by the
+  Licensed Patents. The patent license shall not apply to any other
+  combinations which include the Contribution. No hardware per se is
+  licensed hereunder.
+
+  c) Recipient understands that although each Contributor grants the
+  licenses to its Contributions set forth herein, no assurances are
+  provided by any Contributor that the Program does not infringe the
+  patent or other intellectual property rights of any other entity.
+  Each Contributor disclaims any liability to Recipient for claims
+  brought by any other entity based on infringement of intellectual
+  property rights or otherwise. As a condition to exercising the
+  rights and licenses granted hereunder, each Recipient hereby
+  assumes sole responsibility to secure any other intellectual
+  property rights needed, if any. For example, if a third party
+  patent license is required to allow Recipient to Distribute the
+  Program, it is Recipient's responsibility to acquire that license
+  before distributing the Program.
+
+  d) Each Contributor represents that to its knowledge it has
+  sufficient copyright rights in its Contribution, if any, to grant
+  the copyright license set forth in this Agreement.
+
+  e) Notwithstanding the terms of any Secondary License, no
+  Contributor makes additional grants to any Recipient (other than
+  those set forth in this Agreement) as a result of such Recipient's
+  receipt of the Program under the terms of a Secondary License
+  (if permitted under the terms of Section 3).
+
+3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+  a) the Program must also be made available as Source Code, in
+  accordance with section 3.2, and the Contributor must accompany
+  the Program with a statement that the Source Code for the Program
+  is available under this Agreement, and informs Recipients how to
+  obtain it in a reasonable manner on or through a medium customarily
+  used for software exchange; and
+
+  b) the Contributor may Distribute the Program under a license
+  different than this Agreement, provided that such license:
+     i) effectively disclaims on behalf of all other Contributors all
+     warranties and conditions, express and implied, including
+     warranties or conditions of title and non-infringement, and
+     implied warranties or conditions of merchantability and fitness
+     for a particular purpose;
+
+     ii) effectively excludes on behalf of all other Contributors all
+     liability for damages, including direct, indirect, special,
+     incidental and consequential damages, such as lost profits;
+
+     iii) does not attempt to limit or alter the recipients' rights
+     in the Source Code under section 3.2; and
+
+     iv) requires any subsequent distribution of the Program by any
+     party to be under a license that satisfies the requirements
+     of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+  a) it must be made available under this Agreement, or if the
+  Program (i) is combined with other material in a separate file or
+  files made available under a Secondary License, and (ii) the initial
+  Contributor attached to the Source Code the notice described in
+  Exhibit A of this Agreement, then the Program may be made available
+  under the terms of such Secondary Licenses, and
+
+  b) a copy of this Agreement must be included with each copy of
+  the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability ("notices") contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While this
+license is intended to facilitate the commercial use of the Program,
+the Contributor who includes the Program in a commercial product
+offering should do so in a manner which does not create potential
+liability for other Contributors. Therefore, if a Contributor includes
+the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every
+other Contributor ("Indemnified Contributor") against any losses,
+damages and costs (collectively "Losses") arising from claims, lawsuits
+and other legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program
+in a commercial product offering. The obligations in this section do not
+apply to any claims or Losses relating to any actual or alleged
+intellectual property infringement. In order to qualify, an Indemnified
+Contributor must: a) promptly notify the Commercial Contributor in
+writing of such claim, and b) allow the Commercial Contributor to control,
+and cooperate with the Commercial Contributor in, the defense and any
+related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those performance
+claims and warranties, and if a court requires any other Contributor to
+pay any damages as a result, the Commercial Contributor must pay
+those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS"
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all
+risks associated with its exercise of rights under this Agreement,
+including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs
+or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further
+action by the parties hereto, such provision shall be reformed to the
+minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other software
+or hardware) infringes such Recipient's patent(s), then such Recipient's
+rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of
+time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use
+and distribution of the Program as soon as reasonably practicable.
+However, Recipient's obligations under this Agreement and any licenses
+granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted and
+may only be modified in the following manner. The Agreement Steward
+reserves the right to publish new versions (including revisions) of
+this Agreement from time to time. No one other than the Agreement
+Steward has the right to modify this Agreement. The Eclipse Foundation
+is the initial Agreement Steward. The Eclipse Foundation may assign the
+responsibility to serve as the Agreement Steward to a suitable separate
+entity. Each new version of the Agreement will be given a distinguishing
+version number. The Program (including Contributions) may always be
+Distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is published,
+Contributor may elect to Distribute the Program (including its
+Contributions) under the new version.
+
+Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+receives no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted
+under this Agreement are reserved. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+Exhibit A - Form of Secondary Licenses Notice
+
+"This Source Code may also be made available under the following
+Secondary Licenses when the conditions for such availability set forth
+in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+version(s), and exceptions or additional permissions here}."
+
+  Simply including a copy of this Agreement, including this Exhibit A
+  is not sufficient to license the Source Code under Secondary Licenses.
+
+  If it is not possible or desirable to put the notice in a particular
+  file, then You may include the notice in a location (such as a LICENSE
+  file in a relevant directory) where a recipient would be likely to
+  look for such a notice.
+
+  You may add additional accurate notices of copyright ownership.

mpscli/demo.py

@@ -0,0 +1,6 @@
+
+from model.builder.SSolutionsRepositoryBuilder import SSolutionsRepositoryBuilder
+
+builder = SSolutionsRepositoryBuilder()
+#repo = builder.build('..\\..\\mps_test_projects\\mps_cli_lanuse_file_per_root')
+repo = builder.build('..\\..\\..\\..\\E3_2.0_Solution\\solutions')

mpscli/model/SConcept.py

@@ -0,0 +1,22 @@
+
+class SConcept:
+
+    def __init__(self, name, uuid):
+        self.name = name
+        self.uuid = uuid
+        self.properties = []
+        self.children = []
+        self.references = []
+
+    def print_concept_details(self):
+        print("concept: " + self.name)
+        print("\tproperties: ")
+        for property in self.properties:
+            print("\t\t" + property)
+        print("\tchildren: ")
+        for child in self.children:
+            print("\t\t" + child)
+        print("\treferences: ")
+        for reference in self.references:
+            print("\t\t" + reference)
+        print("<<<")

mpscli/model/SLanguage.py

@@ -0,0 +1,14 @@
+
+class SLanguage:
+
+    def __init__(self, name, uuid):
+        self.name = name
+        self.uuid = uuid
+        self.concepts = []
+
+
+    def find_concept_by_name(self, name):
+        for c in self.concepts:
+            if c.name == name:
+                return c
+        return None

mpscli/model/SModel.py

@@ -0,0 +1,24 @@
+
+
+class SModel:
+
+    def __init__(self, name, uuid, is_do_not_generate):
+        self.name = name
+        self.uuid = uuid
+        self.root_nodes = []
+        self.path_to_model_file = ""
+        self.is_do_not_generate = is_do_not_generate
+        self.uuid_2_nodes = {}
+
+    def get_nodes(self):
+        res = []
+        for r in self.root_nodes:
+            res.append(r)
+            res.extend(r.get_descendants())
+        return res
+
+    def get_node_by_uuid(self, uuid):
+        if len(self.uuid_2_nodes) == 0:
+            for n in self.get_nodes():
+                self.uuid_2_nodes[n.uuid] = n
+        return self.uuid_2_nodes[uuid]

mpscli/model/SNode.py

@@ -0,0 +1,31 @@
+
+class SNode:
+
+    def __init__(self, uuid, concept, role_in_parent, parent):
+        self.uuid = uuid
+        self.concept = concept
+        self.role_in_parent = role_in_parent
+        self.properties = {}
+        self.references = {}
+        self.children = []
+        self.parent = parent
+
+    def get_property(self, name):
+        return self.properties.get(name)
+
+    def get_reference(self, name):
+        return self.references[name]
+
+    def get_children(self, role):
+        return list(filter(lambda c : c.role_in_parent == role, self.children))
+
+    def get_descendants(self):
+        res = []
+        self.__do_collect_descendants(self, res)
+        return res
+
+    def __do_collect_descendants(self, node, res):
+        res.extend(node.children)
+        for c in node.children:
+            self.__do_collect_descendants(c, res)
+

mpscli/model/SNodeRef.py

@@ -0,0 +1,14 @@
+
+
+class SNodeRef:
+
+    def __init__(self, model_uuid, node_uuid):
+        self.model_uuid = model_uuid
+        self.node_uuid = node_uuid
+
+    def resolve(self, repo):
+        model = repo.get_model_by_uuid(self.model_uuid)
+        if model is None:
+            return None
+        return model.get_node_by_uuid(self.node_uuid)
+

mpscli/model/SRepository.py

@@ -0,0 +1,60 @@
+
+class SRepository:
+
+    def __init__(self):
+        self.solutions = []
+        self.languages = []
+        self.uuid_2_model = {}
+
+    def find_solution_by_name(self, name):
+        for sol in self.solutions:
+            if sol.name == name:
+                return sol
+        return None
+
+    def find_model_by_name(self, name):
+        for sol in self.solutions:
+            for model in sol.models:
+                if model.name == name:
+                    return model
+        return None
+
+    def find_language_by_name(self, name):
+        for lan in self.languages:
+            if lan.name == name:
+                return lan
+        return None
+
+    def find_concept_by_name(self, name):
+        for lan in self.languages:
+            for concept in lan.concepts:
+                if concept.name == name:
+                    return concept
+        return None
+
+    def get_concepts(self):
+        res = []
+        for lan in self.languages:
+            res.extend(lan.concepts)
+        return res
+
+    def get_nodes(self):
+        res = []
+        for sol in self.solutions:
+            for mod in sol.models:
+                res.extend(mod.get_nodes())
+        return res
+
+    def get_nodes_of_concept(self, concept_name):
+        res = []
+        for node in self.get_nodes():
+            if node.concept.name == concept_name:
+                res.append(node)
+        return res
+
+    def get_model_by_uuid(self, uuid):
+        if len(self.uuid_2_model) == 0:
+            for sol in self.solutions:
+                for m in sol.models:
+                    self.uuid_2_model[m.uuid] = m
+        return self.uuid_2_model.get(uuid)

mpscli/model/SSolution.py

@@ -0,0 +1,9 @@
+
+
+class SSolution:
+
+    def __init__(self, name, uuid):
+        self.name = name
+        self.uuid = uuid
+        self.path_to_solution_file = ""
+        self.models = []

mpscli/model/builder/NodeIdEncodingUtils.py

@@ -0,0 +1,24 @@
+
+class NodeIdEncodingUtils:
+    
+    def __init__(self):
+        self.myIndexChars = "0123456789abcdefghijklmnopqrstuvwxyz$_ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        self.MIN_CHAR = ord('$')
+        self.myCharToValue = {}
+        for i in range(0, len(self.myIndexChars)):
+            charValue = ord(self.myIndexChars[i])
+            self.myCharToValue[charValue - self.MIN_CHAR] = i
+
+    # transforms the node id string saved in MPS files and converts it to the proper node id as long 
+    def decode_string(self, uid_string):
+        res = 0
+        c = uid_string[0]
+        value = self.myCharToValue[ord(c) - self.MIN_CHAR]
+        res = value
+        for idx in range(1, len(uid_string)):
+            res = res << 6
+            c = uid_string[idx]
+            value = self.myIndexChars.index(c)
+            res = res | value
+        return res
+      

mpscli/model/builder/SLanguageBuilder.py

@@ -0,0 +1,46 @@
+
+from mpscli.model.SLanguage import SLanguage
+from mpscli.model.SConcept import SConcept
+
+class SLanguageBuilder:
+    languages = {}
+
+    @classmethod
+    def get_language(cls, name, uuid):
+        lan = cls.languages.get(name, None)
+        if lan is None:
+            lan = SLanguage(name, uuid)
+            cls.languages[name] = lan
+        return lan
+
+    @classmethod
+    def get_concept(cls, language, concept_name, concept_uuid):
+        concept = next((c for c in language.concepts if c.name == concept_name), None)
+        if concept is None:
+            concept = SConcept(concept_name, concept_uuid)
+            language.concepts.append(concept)
+        return concept
+
+    @classmethod
+    def get_property(cls, concept, property_name):
+        node_property = next((p for p in concept.properties if p == property_name), None)
+        if node_property is None:
+            concept.properties.append(property_name)
+            node_property = property_name
+        return node_property
+
+    @classmethod
+    def get_child(cls, concept, child_name):
+        child_role = next((c for c in concept.children if c == child_name), None)
+        if child_role is None:
+            concept.children.append(child_name)
+            child_role = child_name
+        return child_role
+
+    @classmethod
+    def get_reference(cls, concept, reference_name):
+        reference_role = next((r for r in concept.references if r == reference_name), None)
+        if reference_role is None:
+            concept.references.append(reference_name)
+            reference_role = reference_name
+        return reference_role

mpscli/model/builder/SModelBuilderBase.py

@@ -0,0 +1,94 @@
+from mpscli.model.SNodeRef import SNodeRef
+from mpscli.model.SModel import SModel
+from mpscli.model.SNode import SNode
+from mpscli.model.builder.SLanguageBuilder import SLanguageBuilder
+
+
+class SModelBuilderBase:
+
+    def __init__(self):
+        self.index_2_concept = {}
+        self.index_2_property = {}
+        self.index_2_child_role_in_parent = {}
+        self.index_2_reference_role = {}
+        self.index_2_imported_model_uuid = {}
+
+    def extract_node(self, my_model, node_xml, parent):
+        root_node_id = node_xml.get("id")
+        root_node_concept = self.index_2_concept[node_xml.get("concept")]
+        child_role_index = node_xml.get("role")
+        if child_role_index is None:
+            child_role = None
+        else:
+            child_role = self.index_2_child_role_in_parent[child_role_index]
+        s_node = SNode(root_node_id, root_node_concept, child_role, parent)
+        for property_xml_node in node_xml.findall("property"):
+            property_role = property_xml_node.get("role")
+            property_value = property_xml_node.get("value")
+            property_name = self.index_2_property[property_role]
+            s_node.properties[property_name] = property_value
+        for ref_xml_node in node_xml.findall("ref"):
+            ref_role = ref_xml_node.get("role")
+            ref_to = ref_xml_node.get("to")
+            if ref_to is None:
+                ref_node_uuid = ref_xml_node.get("node")
+                s_node_ref = SNodeRef(my_model.uuid, ref_node_uuid)
+            else:
+                ref_model_index = ref_to[0 : ref_to.find(":")]
+                ref_node_uuid = ref_to[ref_to.find(":") + 1 : len(ref_to)]
+                s_node_ref = SNodeRef(self.index_2_imported_model_uuid[ref_model_index], ref_node_uuid)
+            ref_name = self.index_2_reference_role[ref_role]
+            s_node.references[ref_name] = s_node_ref
+        for child_node_xml in node_xml.findall("node"):
+            child_node = self.extract_node(my_model, child_node_xml, s_node)
+            s_node.children.append(child_node)
+
+        return s_node
+    @staticmethod
+    def is_model_generatable(model_xml_node):
+        return any(
+            attribute.get("name") == "doNotGenerate" and attribute.get("value") == "true"
+            for attribute in model_xml_node.findall("attribute")
+        )
+
+    def extract_model_core_info(self, model_xml_node):
+        model_ref = model_xml_node.get("ref")
+        model_name = model_ref[model_ref.find("(") + 1 : len(model_ref) - 1]
+        model_uuid = model_ref[0 : model_ref.find("(")]
+        model_is_do_not_generate = self.is_model_generatable(model_xml_node)
+        model = SModel(model_name, model_uuid, model_is_do_not_generate)
+        return model
+
+    def extract_imports_and_registry(self, model_xml_node):
+        imports_xml_node = model_xml_node.find("imports")
+        for import_xml_node in imports_xml_node.findall("import"):
+            import_index = import_xml_node.get("index")
+            imported_model_ref = import_xml_node.get("ref")
+            imported_model_uuid = imported_model_ref[0: imported_model_ref.find("(")]
+            self.index_2_imported_model_uuid[import_index] = imported_model_uuid
+        registry_xml_node = model_xml_node.find("registry")
+        for language_xml_node in registry_xml_node.findall("language"):
+            language_id = language_xml_node.get("id")
+            language_name = language_xml_node.get("name")
+            language = SLanguageBuilder.get_language(language_name, language_id)
+            for concept_xml_node in language_xml_node.findall("concept"):
+                concept_id = concept_xml_node.get("id")
+                concept_name = concept_xml_node.get("name")
+                concept = SLanguageBuilder.get_concept(language, concept_name, concept_id)
+                concept_index = concept_xml_node.get("index")
+                self.index_2_concept[concept_index] = concept
+                for property_xml_node in concept_xml_node.findall("property"):
+                    property_name = property_xml_node.get("name")
+                    property_index = property_xml_node.get("index")
+                    node_property = SLanguageBuilder.get_property(concept, property_name)
+                    self.index_2_property[property_index] = node_property
+                for child_xml_node in concept_xml_node.findall("child"):
+                    child_name = child_xml_node.get("name")
+                    child_index = child_xml_node.get("index")
+                    child = SLanguageBuilder.get_child(concept, child_name)
+                    self.index_2_child_role_in_parent[child_index] = child
+                for reference_xml_node in concept_xml_node.findall("reference"):
+                    reference_name = reference_xml_node.get("name")
+                    reference_index = reference_xml_node.get("index")
+                    reference = SLanguageBuilder.get_reference(concept, reference_name)
+                    self.index_2_reference_role[reference_index] = reference

mpscli/model/builder/SModelBuilderDefaultPersistency.py

@@ -0,0 +1,19 @@
+
+import xml.etree.ElementTree as ET
+from mpscli.model.builder.SModelBuilderBase import SModelBuilderBase
+
+
+class SModelBuilderDefaultPersistency(SModelBuilderBase):
+
+    def build(self, path):
+        tree = ET.parse(path)
+        model_xml_node = tree.getroot()
+        model = self.extract_model_core_info(model_xml_node)
+        model.path_to_model_file = path
+        self.extract_imports_and_registry(model_xml_node)
+
+        for node_xml_node in model_xml_node.findall("node"):
+            root_node = self.extract_node(model, node_xml_node, None)
+            model.root_nodes.append(root_node)
+
+        return model

mpscli/model/builder/SModelBuilderFilePerRootPersistency.py

@@ -0,0 +1,30 @@
+
+from mpscli.model.builder.SModelBuilderBase import SModelBuilderBase
+import xml.etree.ElementTree as ET
+
+
+class SModelBuilderFilePerRootPersistency(SModelBuilderBase):
+
+    def build(self, path):
+        model_file = path / '.model'
+        tree = ET.parse(model_file)
+        model_xml_node = tree.getroot()
+        model = self.extract_model_core_info(model_xml_node)
+        model.path_to_model_file = model_file
+
+        for file in path.iterdir():
+            if file.suffix == '.mpsr':
+                root_node = self.extract_root_node(model, file)
+                model.root_nodes.append(root_node)
+
+        return model
+
+    def extract_root_node(self, model, mpsr_file):
+        tree = ET.parse(mpsr_file)
+        model_xml_node = tree.getroot()
+        self.extract_imports_and_registry(model_xml_node)
+        root_node = model_xml_node.find("node")
+        return self.extract_node(model, root_node, None)
+
+
+

mpscli/model/builder/SSolutionBuilder.py

@@ -0,0 +1,36 @@
+import os
+import xml.etree.ElementTree as ET
+from mpscli.model.SSolution import SSolution
+from mpscli.model.builder.SModelBuilderDefaultPersistency import SModelBuilderDefaultPersistency
+from mpscli.model.builder.SModelBuilderFilePerRootPersistency import SModelBuilderFilePerRootPersistency
+
+
+class SSolutionBuilder:
+
+    def build_solution(self, path_to_msd_file):
+        solution = self.extract_solution_core_info(path_to_msd_file)
+        path_to_solution_dir = path_to_msd_file.parent
+        solution.path_to_solution_file = path_to_msd_file
+        print("building from:", path_to_solution_dir)
+        path_to_models_dir = path_to_solution_dir / 'models'
+        if not os.path.exists(path_to_models_dir):
+            print("ERROR: 'models' directory not found! No model is loaded from path: " + str(path_to_solution_dir))
+            return None
+
+        for path_to_model in path_to_models_dir.iterdir():
+            if path_to_model.is_dir():
+                builder = SModelBuilderFilePerRootPersistency()
+            else:
+                builder = SModelBuilderDefaultPersistency()
+            model = builder.build(path_to_model)
+            solution.models.append(model)
+
+        return solution
+
+    def extract_solution_core_info(self, solution_file):
+        tree = ET.parse(solution_file)
+        solution_xml_node = tree.getroot()
+        solution_name = solution_xml_node.get("name")
+        solution_uuid = solution_xml_node.get("uuid")
+        solution = SSolution(solution_name, solution_uuid)
+        return solution

mpscli/model/builder/SSolutionsRepositoryBuilder.py

@@ -0,0 +1,53 @@
+from timeit import default_timer as timer
+import os
+import sys
+import zipfile
+import shutil
+
+from pathlib import Path
+from mpscli.model.SRepository import SRepository
+from mpscli.model.builder.SLanguageBuilder import SLanguageBuilder
+from mpscli.model.builder.SSolutionBuilder import SSolutionBuilder
+
+class SSolutionsRepositoryBuilder:
+
+    def __init__(self):
+        self.repo = SRepository()
+
+    def build(self, path):
+        if not os.path.exists(path):
+            print("ERROR: path", path, "does not exist!")
+            sys.exit(1)
+        if not os.path.isdir(path):
+            print("ERROR: path", path, "is not a directory!")
+            sys.exit(1)
+
+        print("building model from path:", path)
+        start = timer()
+        self.collect_solutions_from_sources(path)
+        self.collect_solutions_from_jars(path)
+        self.repo.languages = list(SLanguageBuilder.languages.values())
+        stop = timer()
+        duration = (stop - start)
+        print('duration is: ' + str(duration) + ' seconds')
+        return self.repo
+
+    def collect_solutions_from_sources(self, path):
+        for pth in Path(path).rglob('*.msd'):
+            solutionBuilder = SSolutionBuilder()
+            solution = solutionBuilder.build_solution(pth)
+            if solution is not None:
+                self.repo.solutions.append(solution)
+
+    def collect_solutions_from_jars(self, path):
+        for jar_path in Path(path).rglob('*.jar'):
+            directory_where_to_extract = jar_path.parent / jar_path.name.replace(".", "_")
+            directory_where_to_extract.mkdir(parents=True, exist_ok=True)
+            with zipfile.ZipFile(jar_path) as jar:
+                jar.extractall(directory_where_to_extract)
+                print("path = ", directory_where_to_extract)
+                self.collect_solutions_from_sources(directory_where_to_extract)
+            try:
+                shutil.rmtree(directory_where_to_extract)
+            except OSError as e:
+                print("Error: %s - %s." % (e.filename, e.strerror))