mal-toolbox 1.2.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

{mal_toolbox-1.2.1.dist-info → mal_toolbox-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mal-toolbox
-Version: 1.2.1
+Version: 2.0.0
 Summary: A collection of tools used to create MAL models and attack graphs.
 Author-email: Andrei Buhaiu <buhaiu@kth.se>, Joakim Loxdal <loxdal@kth.se>, Nikolaos Kakouros <nkak@kth.se>, Jakob Nyberg <jaknyb@kth.se>, Giuseppe Nebbione <nebbione@kth.se>, Sandor Berglund <sandor@kth.se>
 License: Apache Software License
@@ -25,6 +25,8 @@ Requires-Dist: docopt
 Requires-Dist: PyYAML
 Requires-Dist: py2neo
 Requires-Dist: networkx
+Requires-Dist: tree-sitter-mal~=1.0.0
+Requires-Dist: tree-sitter
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Dynamic: license-file
@@ -36,37 +38,9 @@ MAL ([Meta Attack Language](https://mal-lang.org/)) models and attack graphs.
 
 Attack graphs can be used to run simulations in [MAL Simulator](https://github.com/mal-lang/mal-simulator) or run your own custom analysis on.
 
-- [MAL Toolbox Documentation](https://mal-lang.org/mal-toolbox/index.html)
+- [MAL Toolbox Documentation](https://github.com/mal-lang/mal-toolbox/wiki)
 - [MAL Toolbox tutorial](https://github.com/mal-lang/mal-toolbox-tutorial)
 
-## The Language Module
-
-The language module provides various tools to process MAL languages.
-
-## The Model Module
-
-With a MAL language a Model (a MAL instance model) can be created either
-from a model file or empty.
-
-The model class will store all of the relevant information to the MAL
-instance model, most importantly the assets and their associations.
-
-Model objects can be used to generate attack graphs with the AttackGraph module.
-
-## The Attack Graph Module
-
-The attack graph module contains tools used to generate attack graphs from
-existing MAL instance models and analyse MAL attack graphs. The function used
-to generate the attack graph is `generate_graph` and it requires the instance
-model and language specification. The resulting attack graph will contain
-nodes for each of the attack steps. The structure of the attack node data
-class can be seen in `attackgraph/node.py` file. Of note are the lists of
-children and parents which allow for easy reference to the other attack step
-nodes related and the asset field which will contain the object in the model
-instance to which this attack step belongs to, if this information is
-available.
-
-
 # Usage
 
 ## Installation
@@ -147,50 +121,9 @@ Notes:
       compiler) or a .mal file containing the DSL written in MAL.```
 ```
 
-## Code examples / Tutorial
-
-To find more code examples and tutorials, visit the
-[MAL Toolbox Tutorial](https://github.com/mal-lang/mal-toolbox-tutorial/tree/main) repository.
-
-### Load a language
-```python
-
-from maltoolbox.language import LanguageGraph
-
-# Will load the MAL language (.mal/.mar) or a saved language graph (yml/json)
-lang_graph = LanguageGraph.load_from_file(lang_file_path)
-
-```
-
-### Generate a model
-```python
-from maltoolbox.model import Model
-
-# Create an empty model
-instance_model = Model("Example Model", lang_graph)
-
-# Create and add assets of type supported by the MAL language
-asset1 = instance_model.add_asset('Application', 'Application1')
-asset2 = instance_model.add_asset('Application', 'Application2')
-
-# Create association between the assets
-asset1.add_associated_assets('appExecutedApps', asset2)
-```
-
-## Generate an attack graph
-
-```python
-
-from maltoolbox.attackgraph import AttackGraph
-
-attack_graph = AttackGraph(lang_graph, model)
-
-```
-
-
-## Contributing
+# Contributing
 
-# CI Pipeline
+## CI Pipeline
 
 Checks are made with:
 
@@ -200,12 +133,12 @@ Checks are made with:
 
 Make sure pipeline passes before PR is marked "Ready for review".
 
-# Tests
+## Tests
 There are unit tests inside of ./tests.
 
 To run all tests, use the `pytest` command. To run just a specific file or test function use `pytest tests/<filename>` or `pytest -k <function_name>`.
 
-# Making a release
+## Making a release
 
 1. Make a PR with one commit that updates the version number in `pyproject.toml` and `maltoolbox/__init__.py`.
 Follow [Semantic versioning](https://semver.org/).

{mal_toolbox-1.2.1.dist-info → mal_toolbox-2.0.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-mal_toolbox-1.2.1.dist-info/licenses/AUTHORS,sha256=zxLrLe8EY39WtRKlAY4Oorx4Z2_LHV2ApRvDGZgY7xY,127
-mal_toolbox-1.2.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-maltoolbox/__init__.py,sha256=649BOg_Bo4OazvePvnuF2tjM0q4VbyS2Fsz9em_KEtM,2132
+mal_toolbox-2.0.0.dist-info/licenses/AUTHORS,sha256=zxLrLe8EY39WtRKlAY4Oorx4Z2_LHV2ApRvDGZgY7xY,127
+mal_toolbox-2.0.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+maltoolbox/__init__.py,sha256=gxg271599Ua9ptG6IVi2BevMf_0lFpf8iuWi3m5-wrA,2132
 maltoolbox/__main__.py,sha256=aAm6NcZ-HtPmY9hfFlGNnTs5rydoI6NAc88RgXt1G9U,3515
 maltoolbox/exceptions.py,sha256=4rwqzu8Cgj0ShjUoCXP2yik-bJaqYqj6Y-0tqxHy4vs,1316
 maltoolbox/file_utils.py,sha256=IXA0cvyopjRFGGKqRPkRQ0RJOtKzq_XF13aHgcz-TFc,1911
@@ -9,13 +9,16 @@ maltoolbox/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maltoolbox/str_utils.py,sha256=zZXHOFfXguhpQQJ5nyGe1VGWchOkanQUc8viV7nhQho,639
 maltoolbox/attackgraph/__init__.py,sha256=l7dJ7jOqpcj7PdsOKZt1NuXlPyjd6vZYvcXlj8Kq09w,297
 maltoolbox/attackgraph/attackgraph.py,sha256=WBRwnVmQqwpjp3x_kSR8HH49MnlRIhF6tZ_r7nqTAJw,27162
-maltoolbox/attackgraph/node.py,sha256=7NAdEl40w6KMt_gKK1mP4SRAmmyCQGSTMaD-GHMNXHk,4186
+maltoolbox/attackgraph/node.py,sha256=aUlXbkwjcIxwEDWC1fAZl3343mF_Y1rxxF72ncNJcGY,4245
 maltoolbox/attackgraph/analyzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maltoolbox/language/__init__.py,sha256=RTTfhnCYa5PRGJCgDAWLpLLAzNCvNMn91UHNiOXszbg,490
-maltoolbox/language/languagegraph.py,sha256=Tjqk5zv_37ghmepx8KBHPTH8tRlboaYcW836MiUS1d8,65140
-maltoolbox/language/compiler/__init__.py,sha256=Rbdeco6SWHyFw-VJfpxLRSZO3UMjJxPGenMR8OujVpA,15846
-maltoolbox/language/compiler/mal_lexer.py,sha256=TQvzEW7yCN0iY6Js5O6wCDFxSAE0_LAX4JVy96TnLro,14808
-maltoolbox/language/compiler/mal_parser.py,sha256=bVfYWRZyyhU-s2tJI-D_YwbVQkl3AHzdrD6LWM0BQbI,116108
+maltoolbox/language/languagegraph.py,sha256=DyNc2ev2492rBifrb5Ql_jfZ4-2rz0KTAmBt75R2FSc,65326
+maltoolbox/language/compiler/__init__.py,sha256=KCtjWlWY1qmDoTOOufZ0Y1b1zcH_W0IlsTLvTZAfS9w,72
+maltoolbox/language/compiler/distributions.py,sha256=i6SqskJy3y7fn9VS6c1aiNIm09Yxc5-cAZ09lz9ZwCk,5979
+maltoolbox/language/compiler/exceptions.py,sha256=nLXxo0JGmreKAMCJIjiODvB0pJ5q24twKSc3dRo81yY,740
+maltoolbox/language/compiler/lang.py,sha256=WHCU-3SFChr69LFFTle-qlnGov0-tc3tnMLwyYRficA,148
+maltoolbox/language/compiler/mal_analyzer.py,sha256=PJL-ubW4Ehif92QYz9fCNr3dPV6EAMt10VqAjbHWKRI,40837
+maltoolbox/language/compiler/mal_compiler.py,sha256=jD5l20106fQyrGK7msrvUFPnzm4iyDhWdgh47ee4GW8,36881
 maltoolbox/patternfinder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maltoolbox/patternfinder/attackgraph_patterns.py,sha256=jw6BlQHXLmiWm9xajLHbUZUWVQGM2qAgMHOs0Yo2YsE,5168
 maltoolbox/translators/__init__.py,sha256=7qbhjeu--s2A-O_031a7xzSq794iQlrrUxM8gE1LxH4,201
@@ -26,8 +29,8 @@ maltoolbox/visualization/draw_io_utils.py,sha256=CgsD0HEFpxZ6ZIWtUZtMekdPB2Irtmv
 maltoolbox/visualization/graphviz_utils.py,sha256=87B2pxRMrlmm2RHu0JM7nQRHWZD0Yt3zCmEwl8xUXdU,4709
 maltoolbox/visualization/neo4j_utils.py,sha256=R2Qm2gC5GDpfiPhhB3oymuBI2W580SRXGVtQuFRYiIA,3496
 maltoolbox/visualization/utils.py,sha256=EZWsxukO5hbRwGFW9GM9ZemKT-nYg-VMCup-SsntaQM,1480
-mal_toolbox-1.2.1.dist-info/METADATA,sha256=Nlsaw-sJu-Pqz6hWme_f6K-hryjFK8-QHYyMqfXBfWA,6696
-mal_toolbox-1.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mal_toolbox-1.2.1.dist-info/entry_points.txt,sha256=oqby5O6cUP_OHCm70k_iYPA6UlbTBf7se1i3XwdK3uU,56
-mal_toolbox-1.2.1.dist-info/top_level.txt,sha256=phqRVLRKGdSUgRY03mcpi2cmbbDo5YGjkV4gkqHFFcM,11
-mal_toolbox-1.2.1.dist-info/RECORD,,
+mal_toolbox-2.0.0.dist-info/METADATA,sha256=jBkfjs3GBtO0pvOQYVBMpNt9z8nHgvMyjKaA7DxT_Wo,4632
+mal_toolbox-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mal_toolbox-2.0.0.dist-info/entry_points.txt,sha256=oqby5O6cUP_OHCm70k_iYPA6UlbTBf7se1i3XwdK3uU,56
+mal_toolbox-2.0.0.dist-info/top_level.txt,sha256=phqRVLRKGdSUgRY03mcpi2cmbbDo5YGjkV4gkqHFFcM,11
+mal_toolbox-2.0.0.dist-info/RECORD,,

maltoolbox/__init__.py

@@ -1,4 +1,4 @@
-# MAL Toolbox v1.2.1
+# MAL Toolbox v2.0.0
 # Copyright 2025, Andrei Buhaiu.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,7 +19,7 @@
 """
 
 __title__ = "maltoolbox"
-__version__ = "1.2.1"
+__version__ = "2.0.0"
 __authors__ = [
     "Andrei Buhaiu",
     "Giuseppe Nebbione",

maltoolbox/attackgraph/node.py

@@ -28,6 +28,7 @@ class AttackGraphNode:
         self.lg_attack_step = lg_attack_step
         self.name = lg_attack_step.name
         self.type = lg_attack_step.type
+        self.causal_mode = self.lg_attack_step.causal_mode
         self.ttc = ttc_dist if ttc_dist is not None else lg_attack_step.ttc
         self.tags = lg_attack_step.tags
         self.detectors = lg_attack_step.detectors

maltoolbox/language/compiler/__init__.py

@@ -1,500 +1,5 @@
-# mypy: ignore-errors
-import sys
-from collections.abc import MutableMapping, MutableSequence
-from pathlib import Path
+from .mal_compiler import MalCompiler
 
-from antlr4 import CommonTokenStream, FileStream, ParseTreeVisitor
-from antlr4.error.ErrorListener import ConsoleErrorListener
-
-from .mal_lexer import malLexer
-from .mal_parser import malParser
-
-# In a rule like `rule: one? two* three`:
-#   - ctx.one() would be None if the token was not found on a matching line
-#   - ctx.two() would be []
-
-
-def patched_antrl_syntax_error(self, recognizer, offendingSymbol, line, column, msg, e):
-    file = patched_antrl_syntax_error.file
-    print(f"{file}:{line!s}:{column!s}: {msg}", file=sys.stderr)
-
-
-ConsoleErrorListener.syntaxError = patched_antrl_syntax_error
-
-
-class MalCompiler(ParseTreeVisitor):
-    def __init__(self, *args, **kwargs):
-        self.current_file: Path = None
-        self.visited_files: set[Path] = set()
-        self.path_stack: list[Path] = []
-
-        super().__init__(*args, **kwargs)
-
-    def compile(self, malfile: Path | str):
-        current_file = Path(malfile)
-
-        if not current_file.is_absolute() and self.path_stack:
-            # Only for the first file self.path_stack will be empty.
-            current_file = self.path_stack[-1] / current_file
-
-        if current_file in self.visited_files:
-            # Avoid infinite loops due to recursive includes
-            return {}
-
-        self.visited_files.add(current_file)
-        self.path_stack.append(current_file.parent)
-
-        patched_antrl_syntax_error.file = current_file.relative_to(self.path_stack[0])
-
-        input_stream = FileStream(current_file, encoding="utf-8")
-        lexer = malLexer(input_stream)
-        stream = CommonTokenStream(lexer)
-        parser = malParser(stream)
-        tree = parser.mal()
-
-        result = self.visit(tree)
-
-        self.path_stack.pop()
-
-        return result
-
-    def visitMal(self, ctx):
-        langspec = {
-            "formatVersion": "1.0.0",
-            "defines": {},
-            "categories": [],
-            "assets": [],
-            "associations": [],
-        }
-
-        # no visitDeclaration method needed, `declaration` is a thin rule
-        for declaration in (d.getChild(0) for d in ctx.declaration()):
-            if result := self.visit(declaration) or True:
-                key, value = result
-
-                if key == "categories":
-                    category, assets = value
-                    langspec["categories"].extend(category)
-                    langspec["assets"].extend(assets)
-                    continue
-
-                if key == "defines":
-                    langspec[key].update(value)
-
-                if key == "associations":
-                    langspec[key].extend(value)
-
-                if key == "include":
-                    included_file = self.compile(value)
-                    for k, v in langspec.items():
-                        if isinstance(v, MutableMapping):
-                            v.update(included_file.get(k, {}))
-                        if isinstance(v, MutableSequence) and k in included_file:
-                            v.extend(included_file[k])
-
-        for key in ("categories", "assets", "associations"):
-            unique = []
-            for item in langspec[key]:
-                if item not in unique:
-                    unique.append(item)
-            langspec[key] = unique
-
-        return langspec
-
-    def visitInclude(self, ctx):
-        return ("include", ctx.STRING().getText().strip('"'))
-
-    def visitDefine(self, ctx):
-        return ("defines", {ctx.ID().getText(): ctx.STRING().getText().strip('"')})
-
-    def visitDetector(self, ctx):
-        detector = {}
-        detector["name"] = (
-            self.visit(ctx.detectorname()) if ctx.detectorname() else None
-        )
-        detector["context"] = self.visit(ctx.context()) if ctx.context() else None
-        detector["type"] = (
-            self.visit(ctx.detectortype()) if ctx.detectortype() else None
-        )
-        detector["tprate"] = self.visit(ctx.tprate()) if ctx.tprate() else None
-
-        return detector
-
-    def visitDetectorname(self, ctx):
-        return ctx.getText()
-
-    def visitContext(self, ctx):
-        return {
-            # Using labels as the dict keys since multiple contextparts can
-            # share the same asset type.
-            # TODO: add analyzer check if two labels are same in a context
-            cpart.contextlabel().getText(): cpart.contextasset().getText()
-            for cpart in ctx.contextpart()
-        }
-
-    def visitDetectortype(self, ctx):
-        return ctx.getText()
-
-    def visitCategory(self, ctx):
-        category = {}
-        category["name"] = ctx.ID().getText()
-        category["meta"] = {
-            (info := self.visit(meta))[0]: info[1] for meta in ctx.meta()
-        }
-
-        assets = [self.visit(asset) for asset in ctx.asset()]
-
-        return ("categories", ([category], assets))
-
-    def visitMeta(self, ctx):
-        return (ctx.ID().getText(), ctx.text().getText().strip("\"'"))
-
-    def visitAsset(self, ctx):
-        asset = {}
-        asset["name"] = ctx.ID()[0].getText()
-        asset["meta"] = {(info := self.visit(meta))[0]: info[1] for meta in ctx.meta()}
-        asset["category"] = ctx.parentCtx.ID().getText()
-        asset["isAbstract"] = ctx.ABSTRACT() is not None
-
-        asset["superAsset"] = None
-        if len(ctx.ID()) > 1 and ctx.ID()[1]:
-            asset["superAsset"] = ctx.ID()[1].getText()
-
-        asset["variables"] = [self.visit(variable) for variable in ctx.variable()]
-        asset["attackSteps"] = [self.visit(step) for step in ctx.step()]
-
-        return asset
-
-    def visitStep(self, ctx):
-        step = {}
-        step["name"] = ctx.ID().getText()
-        step["meta"] = {(info := self.visit(meta))[0]: info[1] for meta in ctx.meta()}
-
-        # TODO: add analyzer check for conflicting detector names
-        step["detectors"] = {
-            (d := self.visit(detector))["name"]: d for detector in ctx.detector()
-        }
-        step["type"] = self.visit(ctx.steptype())
-        step["tags"] = [self.visit(tag) for tag in ctx.tag()]
-        step["risk"] = self.visit(ctx.cias()) if ctx.cias() else None
-
-        # TODO: left as "ttc" for compatibility reasons
-        step["ttc"] = self.visit(ctx.pdist()) if ctx.pdist() else None
-
-        step["requires"] = (
-            self.visit(ctx.precondition()) if ctx.precondition() else None
-        )
-        step["reaches"] = self.visit(ctx.reaches()) if ctx.reaches() else None
-
-        return step
-
-    def visitSteptype(self, ctx):
-        return (
-            "or"
-            if ctx.OR()
-            else "and"
-            if ctx.AND()
-            else "defense"
-            if ctx.HASH()
-            else "exist"
-            if ctx.EXISTS()
-            else "notExist"
-            if ctx.NOTEXISTS()
-            else None  # should never happen, the grammar limits it
-        )
-
-    def visitTag(self, ctx):
-        return ctx.ID().getText()
-
-    def visitCias(self, ctx):
-        risk = {
-            "isConfidentiality": False,
-            "isIntegrity": False,
-            "isAvailability": False,
-        }
-
-        for cia in ctx.cia():
-            risk.update(self.visit(cia))
-
-        return risk
-
-    def visitCia(self, ctx):
-        key = (
-            "isConfidentiality"
-            if ctx.C()
-            else "isIntegrity"
-            if ctx.I()
-            else "isAvailability"
-            if ctx.A()
-            else None
-        )
-
-        return {key: True}
-
-    def visitPdist(self, ctx):
-        ret = self.visit(ctx.pdistexpr())
-
-        return ret
-
-    def visitPdistexpr(self, ctx):
-        if len(terms := ctx.pdistterm()) == 1:
-            return self.visit(terms[0])
-
-        ret = {}
-
-        lhs = self.visit(terms[0])
-        for i in range(1, len(terms)):
-            ret["type"] = (
-                "addition"
-                if ctx.children[2 * i - 1].getText() == "+"
-                else "subtraction"
-            )
-            ret["lhs"] = lhs
-            ret["rhs"] = self.visit(terms[i])
-
-            lhs = ret.copy()
-
-        return ret
-
-    def visitPdistterm(self, ctx):
-        if len(factors := ctx.pdistfact()) == 1:
-            ret = self.visit(factors[0])
-        else:
-            ret = {}
-            ret["type"] = "multiplication" if ctx.STAR() else "division"
-            ret["lhs"] = self.visit(factors[0])
-            ret["rhs"] = self.visit(factors[1])
-
-        return ret
-
-    def visitPdistfact(self, ctx):
-        if len(atoms := ctx.pdistatom()) == 1:
-            ret = self.visit(atoms[0])
-        else:
-            ret = {}
-            ret["type"] = "exponentiation"
-            ret["lhs"] = self.visit(atoms[0])
-            ret["rhs"] = self.visit(atoms[1])
-
-        return ret
-
-    def visitPdistatom(self, ctx):
-        if ctx.pdistdist():
-            ret = self.visit(ctx.pdistdist())
-        elif ctx.pdistexpr():
-            ret = self.visit(ctx.pdistexpr())
-        elif ctx.number():
-            ret = self.visit(ctx.number())
-
-        return ret
-
-    def visitPdistdist(self, ctx):
-        ret = {"type": "function"}
-        ret["name"] = ctx.ID().getText()
-        ret["arguments"] = []
-
-        if ctx.LPAREN():
-            ret["arguments"] = [self.visit(number)["value"] for number in ctx.number()]
-
-        return ret
-
-    def visitPrecondition(self, ctx):
-        ret = {}
-        ret["overrides"] = True
-        ret["stepExpressions"] = [self.visit(expr) for expr in ctx.expr()]
-        return ret
-
-    def visitReaches(self, ctx):
-        ret = {}
-        ret["overrides"] = ctx.INHERITS() is None
-        ret["stepExpressions"] = [self.visit(expr) for expr in ctx.expr()]
-
-        return ret
-
-    def visitNumber(self, ctx):
-        ret = {"type": "number"}
-        ret["value"] = float(ctx.getText())
-
-        return ret
-
-    def visitVariable(self, ctx):
-        ret = {}
-        ret["name"] = ctx.ID().getText()
-        ret["stepExpression"] = self.visit(ctx.expr())
-
-        return ret
-
-    def visitExpr(self, ctx):
-        if len(ctx.parts()) == 1:
-            return self.visit(ctx.parts()[0])
-
-        ret = {}
-        lhs = self.visit(ctx.parts()[0])
-        for i in range(1, len(ctx.parts())):
-            ret["type"] = self.visit(ctx.children[2 * i - 1])
-            ret["lhs"] = lhs
-            ret["rhs"] = self.visit(ctx.parts()[i])
-            lhs = ret.copy()
-
-        return ret
-
-    def visitParts(self, ctx):
-        if len(ctx.part()) == 1:
-            return self.visit(ctx.part()[0])
-
-        ret = {}
-
-        lhs = self.visit(ctx.part()[0])
-
-        for i in range(1, len(ctx.part())):
-            ret["type"] = "collect"
-            ret["lhs"] = lhs
-            ret["rhs"] = self.visit(ctx.part()[i])
-
-            lhs = ret.copy()
-
-        return ret
-
-    def visitPart(self, ctx):
-        ret = {}
-        if ctx.varsubst():
-            ret["type"] = "variable"
-            ret["name"] = self.visit(ctx.varsubst())
-        elif ctx.LPAREN():
-            ret = self.visit(ctx.expr())
-        else:  # ctx.ID()
-            # Resolve type: field or attackStep?
-            ret["type"] = self._resolve_part_ID_type(ctx)
-
-            ret["name"] = ctx.ID().getText()
-
-        if ctx.STAR():
-            ret = {"type": "transitive", "stepExpression": ret}
-
-        for type_ in ctx.type_():  # mind the trailing underscore
-            ret = {
-                "type": "subType",
-                "subType": self.visit(type_),
-                "stepExpression": ret,
-            }
-
-        return ret
-
-    def _resolve_part_ID_type(self, ctx):
-        pctx = ctx.parentCtx
-
-        # Traverse up the tree until we find the parent of the topmost expr
-        # (saying "topmost" as expr can be nested) or the root of the tree.
-        while pctx and not isinstance(
-            pctx,
-            malParser.ReachesContext,
-            # Expressions are also valid in `let` variable assignments, but
-            # there every lexical component of expr is considered a "field",
-            # no need to resolve the type in that case. Similarly, preconditions
-            # (`<-`) only accept fields.
-        ):
-            pctx = pctx.parentCtx
-
-        if pctx is None:
-            # ctx (the `part`) belongs to a "let" assignment or a precondition.
-            return "field"
-
-        # scan for a dot to the right of `ctx`
-        file_tokens = ctx.parser.getTokenStream().tokens
-        for i in range(ctx.start.tokenIndex, pctx.stop.tokenIndex + 1):
-            if file_tokens[i].type == malParser.DOT:
-                return "field"
-
-            # We are looping until the end of pctx (which is a `reaches` or
-            # `precondition` context). This could include multiple comma
-            # separated `expr`s, we only care for the current one.
-            if file_tokens[i].type == malParser.COMMA:  # end of current `expr`
-                return "attackStep"
-
-        return "attackStep"
-
-    def visitVarsubst(self, ctx):
-        return ctx.ID().getText()
-
-    def visitType(self, ctx):
-        return ctx.ID().getText()
-
-    def visitSetop(self, ctx):
-        return (
-            "union"
-            if ctx.UNION()
-            else "intersection"
-            if ctx.INTERSECT()
-            else "difference"
-            if ctx.INTERSECT
-            else None
-        )
-
-    def visitAssociations(self, ctx):
-        associations = []
-        for assoc in ctx.association():
-            associations.append(self.visit(assoc))
-
-        return ("associations", associations)
-
-    def visitAssociation(self, ctx):
-        association = {}
-
-        association["name"] = self.visit(ctx.linkname())
-        association["meta"] = {
-            (info := self.visit(meta))[0]: info[1] for meta in ctx.meta()
-        }
-        association["leftAsset"] = ctx.ID()[0].getText()
-        association["leftField"] = self.visit(ctx.field()[0])
-
-        # no self.visitMult or self.visitMultatom methods, reading them here
-        # directly
-        association["leftMultiplicity"] = {
-            "min": (multatoms := ctx.mult()[0].multatom()).pop(0).getText(),
-            "max": multatoms.pop().getText() if multatoms else None,
-        }
-        association["rightAsset"] = ctx.ID()[1].getText()
-        association["rightField"] = self.visit(ctx.field()[1])
-        association["rightMultiplicity"] = {
-            "min": (multatoms := ctx.mult()[1].multatom()).pop(0).getText(),
-            "max": multatoms.pop().getText() if multatoms else None,
-        }
-
-        self._post_process_multitudes(association)
-        return association
-
-    def _post_process_multitudes(self, association):
-        mult_keys = [
-            # start the multatoms from right to left to make sure the rules
-            # below get applied cleanly
-            "rightMultiplicity.max",
-            "rightMultiplicity.min",
-            "leftMultiplicity.max",
-            "leftMultiplicity.min",
-        ]
-
-        for mult_key in mult_keys:
-            key, subkey = mult_key.split(".")
-
-            # upper limit equals lower limit if not given
-            if subkey == "max" and association[key][subkey] is None:
-                association[key][subkey] = association[key]["min"]
-
-            if association[key][subkey] == "*":
-                # 'any' as lower limit means start from 0
-                if subkey == "min":
-                    association[key][subkey] = 0
-
-                # 'any' as upper limit means not limit
-                else:
-                    association[key][subkey] = None
-
-            # cast numerical strings to integers
-            if (multatom := association[key][subkey]) and multatom.isdigit():
-                association[key][subkey] = int(association[key][subkey])
-
-    def visitField(self, ctx):
-        return ctx.ID().getText()
-
-    def visitLinkname(self, ctx):
-        return ctx.ID().getText()
+__all__ = [
+    'MalCompiler',
+]