mal-toolbox 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

maltoolbox/translators/updater.py

@@ -3,130 +3,253 @@ import logging
 
 import yaml
 
-from ..model import Model, AttackerAttachment
-from ..language import LanguageClassesFactory
+import logging
+from ..model import Model
+from ..language import LanguageGraph
+from ..file_utils import load_dict_from_json_file, load_dict_from_yaml_file
 
 logger = logging.getLogger(__name__)
 
 def load_model_from_older_version(
-        filename: str,
-        lang_classes_factory: LanguageClassesFactory,
-        version: str
+        filename: str, lang_graph: LanguageGraph,
     ) -> Model:
-    match (version):
-        case '0.0.39':
-            return load_model_from_version_0_0_39(filename,
-                lang_classes_factory)
-        case _:
-            msg = ('Unknown version "%s" format. Could not '
-            'load model from file "%s"')
-            logger.error(msg % (version, filename))
-            raise ValueError(msg % (version, filename))
 
-def load_model_from_version_0_0_39(
-        filename: str,
-        lang_classes_factory: LanguageClassesFactory
-    ) -> Model:
-    """
-    Load model from file.
+    """ Load an older Model file
 
-    Arguments:
-    filename                - the name of the input file
-    lang_classes_factory    - the language classes factory that defines the
-                              classes needed to build the model
+    Load an older model from given `filename` (yml/json)
+    convert the model to the new format and return a Model object. 
     """
 
-    def _process_model(model_dict, lang_classes_factory) -> Model:
-        model = Model(model_dict['metadata']['name'], lang_classes_factory)
+    model_dict = load_model_dict_from_file(filename)
 
-        # Reconstruct the assets
-        for asset_id, asset_object in model_dict['assets'].items():
-            logger.debug(f"Loading asset:\n{json.dumps(asset_object, indent=2)}")
+    # Get the version of the model, default to 0.0
+    # since metadata was not given back then
+    version = model_dict.get(
+        'metadata', {}
+    ).get('MAL-Toolbox Version', '0.0.')
 
-            # Allow defining an asset via the metaconcept only.
-            asset_object = (
-                asset_object
-                if isinstance(asset_object, dict)
-                else {'metaconcept': asset_object, 'name': f"{asset_object}:{asset_id}"}
+    match (version):
+        case x if '0.0.' in x:
+            model_dict = convert_model_dict_from_version_0_0(model_dict)
+            model_dict = convert_model_dict_from_version_0_1(model_dict)
+            model_dict = convert_model_dict_from_version_0_2(model_dict)
+        case x if '0.1.' in x:
+            model_dict = convert_model_dict_from_version_0_1(model_dict)
+            model_dict = convert_model_dict_from_version_0_2(model_dict)
+        case x if '0.2.' in x:
+            model_dict = convert_model_dict_from_version_0_2(model_dict)
+        case _:
+            msg = (
+                'Unknown version "%s" format.'
+                'Could not load model from file "%s"'
             )
+            logger.error(msg, version, filename)
+            raise ValueError(msg % (version, filename))
+
+    # TODO: _from_dict should be public
+    return Model._from_dict(model_dict, lang_graph)
+
 
-            asset = getattr(model.lang_classes_factory.ns,
-                asset_object['metaconcept'])(name = asset_object['name'])
-
-            for defense in (defenses:=asset_object.get('defenses', [])):
-                setattr(asset, defense, float(defenses[defense]))
-
-            model.add_asset(asset, asset_id = int(asset_id))
-
-        # Reconstruct the associations
-        for assoc_dict in model_dict.get('associations', []):
-            association = getattr(model.lang_classes_factory.ns, assoc_dict.pop('metaconcept'))()
-
-            # compatibility with old format
-            assoc_dict = assoc_dict.get('association', assoc_dict)
-
-            for field, targets in assoc_dict.items():
-                targets = targets if isinstance(targets, list) else [targets]
-                setattr(
-                    association,
-                    field,
-                    [model.get_asset_by_id(int(id)) for id in targets]
-                )
-            model.add_association(association)
-
-        # Reconstruct the attackers
-        if 'attackers' in model_dict:
-            attackers_info = model_dict['attackers']
-            for attacker_id in attackers_info:
-                attacker = AttackerAttachment(
-                    name = attackers_info[attacker_id]['name']
-                )
-                attacker.entry_points = []
-                for asset_id in attackers_info[attacker_id]['entry_points']:
-                    attacker.entry_points.append(
-                        (model.get_asset_by_id(int(asset_id)),
-                        attackers_info[attacker_id]['entry_points']\
-                            [asset_id]['attack_steps']))
-                model.add_attacker(attacker, attacker_id = int(attacker_id))
-        return model
-
-    def load_from_json(
-            filename: str,
-            lang_classes_factory: LanguageClassesFactory
-        ) -> Model:
-        """
-        Load model from a json file.
-
-        Arguments:
-        filename        - the name of the input file
-        """
-        with open(filename, 'r', encoding='utf-8') as model_file:
-            model_dict = json.loads(model_file.read())
-
-        return _process_model(model_dict, lang_classes_factory)
-
-    def load_from_yaml(
-            filename: str,
-            lang_classes_factory: LanguageClassesFactory
-        ) -> Model:
-        """
-        Load model from a yaml file.
-
-        Arguments:
-        filename        - the name of the input file
-        """
-        with open(filename, 'r', encoding='utf-8') as model_file:
-            model_dict = yaml.safe_load(model_file)
-
-        return _process_model(model_dict, lang_classes_factory)
-
-    logger.info(f'Loading model from {filename} file.')
+def load_model_dict_from_file(
+    filename: str,
+    ) -> dict:
+    """Load a json or yaml file to dict"""
+
+    model_dict = {}
     if filename.endswith('.yml') or filename.endswith('.yaml'):
-        return load_from_yaml(filename, lang_classes_factory)
+        model_dict = load_dict_from_yaml_file(filename)
     elif filename.endswith('.json'):
-        return load_from_json(filename, lang_classes_factory)
+        model_dict = load_dict_from_json_file(filename)
     else:
         msg = 'Unknown file extension for model file to load from.'
         logger.error(msg)
         raise ValueError(msg)
-    return None
+    return model_dict
+
+
+def convert_model_dict_from_version_0_0(model_dict: dict) -> dict:
+    """
+    Convert model dict version 0.0 to 0.1
+
+    Arguments:
+    model_dict  - the dictionary containing the serialized model
+
+    Returns:
+    A dictionary containing the version 0.1 equivalent serialized model
+    """
+
+    new_model_dict = {}
+
+    # Meta data and attackers did not change
+    new_model_dict['metadata'] = model_dict['metadata']
+    new_model_dict['attackers'] = model_dict['attackers']
+
+    new_model_dict['assets'] = {}
+
+    # Reconstruct the assets
+    new_assets_dict = {}
+    for asset_id, asset_info in model_dict['assets'].items():
+        # Make sure asset ids are ints for json compatibility
+        asset_id = int(asset_id)
+        new_assets_dict[asset_id] = asset_info
+
+        # Metaconcept renamed to type
+        new_assets_dict[asset_id]["type"] = (
+            new_assets_dict[asset_id]["metaconcept"]
+        )
+        del new_assets_dict[asset_id]["metaconcept"]
+
+    new_model_dict['assets'] = new_assets_dict
+
+    # Reconstruct the associations dict in new format
+    new_assoc_list = []
+    for assoc_dict in model_dict.get('associations', []):
+        new_assoc_dict: dict[str, dict] = {}
+
+        # Assocs are not mapped from association names
+        # metaconcept field removed
+        assoc_name = assoc_dict['metaconcept']
+        new_assoc_dict[assoc_name] = {}
+
+        for field, targets in assoc_dict['association'].items():
+            # Targets are now intes
+            new_targets = [int(asset_id) for asset_id in targets]
+            new_assoc_dict[assoc_name][field] = new_targets
+
+        new_assoc_list.append(new_assoc_dict)
+
+    # Add new assoc dict to new model dict
+    new_model_dict['associations'] = new_assoc_list
+
+    # Reconstruct the attackers
+    if 'attackers' in model_dict:
+        attackers_info = model_dict['attackers']
+
+    return new_model_dict
+
+
+def convert_model_dict_from_version_0_1(model_dict: dict) -> dict:
+    """
+    Convert model dict version 0.1 to 0.2
+
+    Arguments:
+    model_dict  - the dictionary containing the serialized model
+
+    Returns:
+    A dictionary containing the version 0.2 equivalent serialized model
+    """
+
+    new_model_dict = {}
+
+    # Meta data and assets format did not change from version 0.1
+    new_model_dict['metadata'] = model_dict['metadata']
+
+    new_assets_dict = {}
+    for asset_id, asset_info in model_dict['assets'].items():
+        # Make sure asset ids are ints for json compatibility
+        asset_id = int(asset_id)
+        new_assets_dict[asset_id] = asset_info
+
+    new_model_dict['assets'] = new_assets_dict
+
+    # Reconstruct the associations dict in new format
+    new_assoc_list = []
+    for assoc_dict in model_dict.get('associations', []):
+        new_assoc_dict: dict[str, dict] = {}
+
+        assert len(assoc_dict.keys()) == 1, (
+            "Only one key per association in model file allowed"
+        )
+
+        assoc_name = list(assoc_dict.keys())[0]
+        new_assoc_name = assoc_name.split("_")[0]
+        new_assoc_dict[new_assoc_name] = {}
+        for field, targets in assoc_dict[assoc_name].items():
+            new_assoc_dict[new_assoc_name][field] = targets
+
+        new_assoc_list.append(new_assoc_dict)
+
+    # Add new assoc dict to new model dict
+    new_model_dict['associations'] = new_assoc_list
+
+    # Reconstruct attackers dict for new format
+    new_attackers_dict: dict[int, dict] = {}
+    attackers_dict: dict = model_dict.get('attackers', {})
+    for attacker_id, attacker_dict in attackers_dict.items():
+        attacker_id = int(attacker_id) # JSON compatibility
+        new_attackers_dict[attacker_id] = {}
+        new_attackers_dict[attacker_id]['name'] = attacker_dict['name']
+        new_entry_points_dict = {}
+
+        entry_points_dict = attacker_dict['entry_points']
+        for asset_id, attack_steps in entry_points_dict.items():
+                asset_id = int(asset_id) # JSON compatibility
+                asset_name = new_assets_dict[asset_id]['name']
+                new_entry_points_dict[asset_name] = {
+                    'asset_id': asset_id,
+                    'attack_steps': attack_steps['attack_steps']
+                }
+
+        new_attackers_dict[attacker_id]['entry_points'] = new_entry_points_dict
+
+    # Add new attackers dict to new model dict
+    new_model_dict['attackers'] = new_attackers_dict
+    return new_model_dict
+
+
+def convert_model_dict_from_version_0_2(model_dict: dict) -> dict:
+    """
+    Convert model dict version 0.2 to 0.3
+
+    Arguments:
+    model_dict  - the dictionary containing the serialized model
+
+    Returns:
+    A dictionary containing the version 0.3 equivalent serialized model
+    """
+
+    new_model_dict = {}
+
+    # Meta data and assets format did not change from version 0.1
+    new_model_dict['metadata'] = model_dict['metadata']
+    new_model_dict['attackers'] = model_dict['attackers']
+
+    new_assets_dict: dict[int, dict] = {}
+    for asset_id, asset_info in model_dict['assets'].items():
+        # Make sure asset ids are ints for json compatibility
+        asset_id = int(asset_id)
+        new_assets_dict[asset_id] = asset_info
+        new_assets_dict[asset_id]['associated_assets'] = {}
+
+    new_model_dict['assets'] = new_assets_dict
+
+    # Reconstruct the associations dict in new format
+    for assocs_dict in model_dict.get('associations', []):
+
+        assert len(assocs_dict.keys()) == 1, (
+            "Only one key per association in model file allowed"
+        )
+
+        assoc_name = list(assocs_dict.keys())[0]
+        assoc_dict = assocs_dict[assoc_name]
+        left_field_name = list(assoc_dict.keys())[0]
+        right_field_name = list(assoc_dict.keys())[1]
+
+        for l_asset_id in assoc_dict[left_field_name]:
+            l_asset_id = int(l_asset_id)  # json compatibility
+            for r_asset_id in assoc_dict[right_field_name]:
+                r_asset_id = int(r_asset_id)  # json compatibility
+                l_asset_dict = new_model_dict['assets'][l_asset_id]
+                r_asset_dict = new_model_dict['assets'][r_asset_id]
+
+                # Add connections from left to right
+                l_asset_dict['associated_assets'].setdefault(
+                    right_field_name, {}
+                )[r_asset_id] = r_asset_dict['name']
+
+                # And from right to left
+                r_asset_dict['associated_assets'].setdefault(
+                    left_field_name, {}
+                )[l_asset_id] = l_asset_dict['name']
+
+    return new_model_dict

mal_toolbox-0.2.0.dist-info/RECORD

@@ -1,32 +0,0 @@
-maltoolbox/__init__.py,sha256=4y4QJcwl6OKw8pCiPaUrOWtXRpEgFrKeoNLajc9p2Iw,2776
-maltoolbox/__main__.py,sha256=1lOOOme_y56VWrEE1jkarTt-WoUo9yilCo8sUrivyns,2680
-maltoolbox/default.conf,sha256=YLGBSJh2q8hn3RzRRBbib9F6E6pcvquoHeALMRtA0wU,295
-maltoolbox/exceptions.py,sha256=0YjPx2v1yYumZ2o7pVZ1s_jS-GAb3Ng979KEFhROSNY,1399
-maltoolbox/file_utils.py,sha256=TFLm32_RLfB4uEsToZ8ypDcRbbdFZMso34mfvqAb1bY,2139
-maltoolbox/model.py,sha256=mQqwx0cSLV6E8wGBSDDKkKnFdbcPeBcjqIpFdBjtkYE,31042
-maltoolbox/wrappers.py,sha256=BYYNcIdTlyumADQCPcy1xmPEabfmi0P1l9RcbdVWm9w,2002
-maltoolbox/attackgraph/__init__.py,sha256=Oqqj5iCwnrzjDoJEFZnVI_kebjJPVbPXK-mWHy0lf-8,209
-maltoolbox/attackgraph/attacker.py,sha256=OaBNDYZF8shbFuQctzuNYVkOrpNb_KhxxV19k0SRa50,3541
-maltoolbox/attackgraph/attackgraph.py,sha256=HLAjF8Qx9W2iv6uSWRULL16ieuy7UM5fLZNwxIr544s,31348
-maltoolbox/attackgraph/node.py,sha256=xrnY_YlX9ZFXDRsj92I9PZMGJR6s1LpTnOIppR6TGXo,6074
-maltoolbox/attackgraph/query.py,sha256=JnoNTUEIlLv2VIk3u5Rq3GpleOn9TZVGBVijniRY_44,6802
-maltoolbox/attackgraph/analyzers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maltoolbox/attackgraph/analyzers/apriori.py,sha256=8dRZL22oym5goXBYtYA1ZYXxk8VwQS0RlNCvNCUhCAY,8743
-maltoolbox/ingestors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maltoolbox/ingestors/neo4j.py,sha256=jdulYsQ2eZT2r0Af_yYjyGkmVx4l5h8viu1Z70NjVAM,8811
-maltoolbox/language/__init__.py,sha256=WNoPtcYHJE799vR6x269Gx5KPWxBgLOHQoycE1vhOF4,257
-maltoolbox/language/classes_factory.py,sha256=-s4xxwcCGgKj1wzrgsrn-ndLhgU4VoEjrrSuGx8qvYE,10217
-maltoolbox/language/languagegraph.py,sha256=ctoxS33DM7F4DF50SNDB2lTtokUJKyWMhMhss46yv_g,68123
-maltoolbox/language/compiler/__init__.py,sha256=fJ22-FlXfr907WCPkqlr_eBTzPqsrg6m3i7J_ZWpuAo,840
-maltoolbox/language/compiler/mal_lexer.py,sha256=wocRzBkLbqYefpGvq2W77x7439-AdZKVgPWhRiRubXg,10776
-maltoolbox/language/compiler/mal_parser.py,sha256=M1EVZFV73TNfQHz2KJ8-iloqOD4KUhHyajszD8UrNow,91349
-maltoolbox/language/compiler/mal_visitor.py,sha256=9gG06D7GZKlBY-62SmbIkRYkGBUBIC6fl1GOg7v2IuM,13223
-maltoolbox/translators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-maltoolbox/translators/securicad.py,sha256=FAIHnoqFTmNYbCGxLsK6pX5g1oiNFfPTqkT_3qq3GG8,6692
-maltoolbox/translators/updater.py,sha256=Ap08-AsU_7or5ESQvZL2i4nWz3B5pvgfftZyc_-Gd8M,4766
-mal_toolbox-0.2.0.dist-info/AUTHORS,sha256=zxLrLe8EY39WtRKlAY4Oorx4Z2_LHV2ApRvDGZgY7xY,127
-mal_toolbox-0.2.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mal_toolbox-0.2.0.dist-info/METADATA,sha256=AWtN4435t5ycp5k-dPfRSVRU4rhpyb6e_z1FBE2PYpY,6001
-mal_toolbox-0.2.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mal_toolbox-0.2.0.dist-info/top_level.txt,sha256=phqRVLRKGdSUgRY03mcpi2cmbbDo5YGjkV4gkqHFFcM,11
-mal_toolbox-0.2.0.dist-info/RECORD,,

maltoolbox/default.conf

@@ -1,17 +0,0 @@
-[logging]
-output_dir = tmp
-log_level =
-log_file = %(output_dir)s/log.txt
-attackgraph_file = %(output_dir)s/attackgraph.yml
-model_file = %(output_dir)s/model.yml
-langspec_file = %(output_dir)s/langspec_file.yml
-
-[input]
-model_file =
-lang_spec_file =
-
-[neo4j]
-uri =
-username =
-password =
-dbname =

maltoolbox/language/classes_factory.py

@@ -1,259 +0,0 @@
-"""
-MAL-Toolbox Language Classes Factory Module
-Uses python_jsonschema_objects to generate python classes from a MAL language
-"""
-from __future__ import annotations
-import json
-import logging
-from typing import TYPE_CHECKING
-
-import python_jsonschema_objects as pjs
-
-if TYPE_CHECKING:
-    from typing import Literal, Optional, TypeAlias
-    from maltoolbox.language import LanguageGraph
-    from python_jsonschema_objects.classbuilder import ProtocolBase
-
-    SchemaGeneratedClass: TypeAlias = ProtocolBase
-
-logger = logging.getLogger(__name__)
-
-class LanguageClassesFactory:
-    def __init__(self, lang_graph: LanguageGraph):
-        self.lang_graph: LanguageGraph = lang_graph
-        self.json_schema: dict = {}
-        self._create_classes()
-
-    def _generate_assets(self) -> None:
-        """
-        Generate JSON Schema for asset types in the language specification.
-        """
-        for asset_name, asset in self.lang_graph.assets.items():
-            logger.debug('Creating %s asset JSON schema entry.', asset.name)
-            asset_json_entry = {
-                'title': 'Asset_' + asset.name,
-                'type': 'object',
-                'properties': {},
-            }
-            asset_json_entry['properties']['id'] = {
-                'type' : 'integer',
-            }
-            asset_json_entry['properties']['type'] = \
-                {
-                    'type' : 'string',
-                    'default': asset_name
-                }
-            if asset.own_super_asset:
-                asset_json_entry['allOf'] = [
-                    {'$ref': '#/definitions/LanguageAsset/definitions/Asset_'\
-                        + asset.own_super_asset.name}
-                ]
-            for step_name, step in asset.attack_steps.items():
-                if step.type == 'defense':
-                    if step.ttc and step.ttc['name'] == 'Enabled':
-                        default_defense_value = 1.0
-                    else:
-                        default_defense_value = 0.0
-                    asset_json_entry['properties'][step_name] = \
-                        {
-                            'type' : 'number',
-                            'minimum' : 0,
-                            'maximum' : 1,
-                            'default': default_defense_value
-                        }
-            self.json_schema['definitions']['LanguageAsset']['definitions']\
-                ['Asset_' + asset_name] = asset_json_entry
-            self.json_schema['definitions']['LanguageAsset']['oneOf'].append(
-                {'$ref': '#/definitions/LanguageAsset/definitions/Asset_' + asset_name}
-            )
-
-    def _generate_associations(self) -> None:
-        """
-        Generate JSON Schema for association types in the language specification.
-        """
-        def create_association_entry(assoc: SchemaGeneratedClass):
-            logger.debug('Creating %s association JSON schema entry.', assoc.name)
-            assoc_json_entry = {
-                'title': 'Association_' + assoc.full_name,
-                'type': 'object',
-                'properties': {}
-            }
-            assoc_json_entry['properties']['type'] = \
-                {
-                    'type' : 'string',
-                    'default': assoc.name
-                }
-
-            create_association_field(assoc, assoc_json_entry, 'left')
-            create_association_field(assoc, assoc_json_entry, 'right')
-            return assoc_json_entry
-
-        def create_association_field(
-                assoc: SchemaGeneratedClass,
-                assoc_json_entry: dict,
-                position: Literal['left', 'right']
-            ) -> None:
-            field = getattr(assoc, position + "_field")
-            assoc_json_entry['properties'][field.fieldname] = \
-                {
-                    'type' : 'array',
-                    'items' :
-                        {
-                        '$ref':
-                        '#/definitions/LanguageAsset/definitions/Asset_' +
-                            field.asset.name
-                        }
-                }
-            if field.maximum:
-                assoc_json_entry['properties'][field.fieldname]\
-                    ['maxItems'] = field.maximum
-
-        for asset_name, asset in self.lang_graph.assets.items():
-            for assoc_name, assoc in asset.associations.items():
-                if assoc_name not in self.json_schema['definitions']\
-                        ['LanguageAssociation']['definitions']:
-                    assoc_json_entry = create_association_entry(assoc)
-                    self.json_schema['definitions']['LanguageAssociation']\
-                        ['definitions']['Association_' + assoc_name] = \
-                            assoc_json_entry
-                    self.json_schema['definitions']['LanguageAssociation']['oneOf'].\
-                        append({'$ref': '#/definitions/LanguageAssociation/' +
-                        'definitions/Association_' + assoc_name})
-
-    def _create_classes(self) -> None:
-        """
-        Create classes based on the language specification.
-        """
-
-        # First, we have to translate the language specification into a JSON
-        # schema. Initialize the overall JSON schema structure.
-        self.json_schema = {
-            '$schema': 'http://json-schema.org/draft-04/schema#',
-            'id': f"urn:mal:{__name__.replace('.', ':')}",
-            'title': 'LanguageObject',
-            'type': 'object',
-            'oneOf':[
-                {'$ref': '#/definitions/LanguageAsset'},
-                {'$ref': '#/definitions/LanguageAssociation'}
-            ],
-            'definitions': {}}
-        self.json_schema['definitions']['LanguageAsset'] = {
-            'title': 'LanguageAsset',
-            'type': 'object',
-            'oneOf': [],
-            'definitions': {}}
-        self.json_schema['definitions']['LanguageAssociation'] = {
-            'title': 'LanguageAssociation',
-            'type': 'object',
-            'oneOf': [],
-            'definitions': {}}
-
-        self._generate_assets()
-        self._generate_associations()
-
-        if logger.isEnabledFor(logging.DEBUG):
-            # Avoid running json.dumps when not in debug
-            logger.debug(json.dumps(self.json_schema, indent = 2))
-
-        # Once we have the JSON schema we create the actual classes.
-        builder = pjs.ObjectBuilder(self.json_schema)
-        self.ns = builder.build_classes(standardize_names=False)
-
-    def get_association_by_signature(
-        self,
-        assoc_name: str,
-        left_asset: str,
-        right_asset: str
-    ) -> Optional[str]:
-        """
-        Get association name based on its signature. This is primarily
-        relevant for getting the exact association full name when multiple
-        associations with the same name exist.
-
-        Arguments:
-        assoc_name          - the association name
-        left_asset          - the name of the left asset type
-        right_asset         - the name of the right asset type
-
-        Return: The matching association name if a match is found.
-        None if there is no match.
-        """
-        lang_assocs_entries = self.json_schema['definitions']\
-                ['LanguageAssociation']['definitions']
-        if not assoc_name in lang_assocs_entries:
-            raise LookupError(
-                'Failed to find "%s" association in the language json '
-                'schema.' % assoc_name
-            )
-        assoc_entry = lang_assocs_entries[assoc_name]
-        # If the association has a oneOf property it should always have more
-        # than just one alternative, but check just in case
-        if 'definitions' in assoc_entry and \
-                len(assoc_entry['definitions']) > 1:
-            full_name = '%s_%s_%s' % (
-                assoc_name,
-                left_asset,
-                right_asset
-            )
-            full_name_flipped = '%s_%s_%s' % (
-                assoc_name,
-                right_asset,
-                left_asset
-            )
-            if not full_name in assoc_entry['definitions']:
-                if not full_name_flipped in assoc_entry['definitions']:
-                    raise LookupError(
-                        'Failed to find "%s" or "%s" association in the '
-                        'language json schema.'
-                        % (full_name,
-                        full_name_flipped)
-                    )
-                else:
-                    return full_name_flipped
-            else:
-                return full_name
-        else:
-            return assoc_name
-
-    def get_asset_class(self,
-            asset_name: str
-        ) -> Optional[SchemaGeneratedClass]:
-        class_name = 'Asset_' + asset_name
-        if hasattr(self.ns, class_name):
-            class_obj = getattr(self.ns, class_name)
-            class_obj.__hash__ = lambda self: hash(self.name)
-            return class_obj
-        else:
-            logger.warning('Could not find Asset "%s" in classes factory.' %
-                asset_name)
-            return None
-
-    def get_association_class(self,
-            assoc_name: str
-        ) -> Optional[SchemaGeneratedClass]:
-        class_name = 'Association_' + assoc_name
-        if hasattr(self.ns, class_name):
-            return getattr(self.ns, class_name)
-        else:
-            logger.warning('Could not find Association "%s" in classes factory.' %
-                assoc_name)
-            return None
-
-    def get_association_class_by_fieldnames(self,
-            assoc_name: str,
-            fieldname1: str,
-            fieldname2: str
-        ) -> Optional[SchemaGeneratedClass]:
-        class_name = 'Association_%s_%s_%s' % (assoc_name,
-            fieldname1, fieldname2)
-        class_name_alt = 'Association_%s_%s_%s' % (assoc_name,
-            fieldname2, fieldname1)
-
-        if hasattr(self.ns, class_name):
-            return getattr(self.ns, class_name)
-        elif hasattr(self.ns, class_name_alt):
-            return getattr(self.ns, class_name_alt)
-        else:
-            logger.warning('Could not find Association "%s" or "%s" in '
-                'classes factory.' % (class_name, class_name_alt))
-            return None