mal-toolbox 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

maltoolbox/attackgraph/node.py

@@ -1,17 +1,18 @@
-"""
-MAL-Toolbox Attack Graph Node
+"""MAL-Toolbox Attack Graph Node
 """
 
 from __future__ import annotations
+
 import copy
 from functools import cached_property
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any, Optional
-    from ..language import LanguageGraphAttackStep, Detector
+
+    from ..language import LanguageGraphAttackStep
     from ..model import ModelAsset
 
+
 class AttackGraphNode:
     """Node part of AttackGraph"""
 
@@ -19,10 +20,10 @@ class AttackGraphNode:
         self,
         node_id: int,
         lg_attack_step: LanguageGraphAttackStep,
-        model_asset: Optional[ModelAsset] = None,
-        ttc_dist: Optional[dict] = None,
-        existence_status: Optional[bool] = None,
-        full_name: Optional[str] = None
+        model_asset: ModelAsset | None = None,
+        ttc_dist: dict | None = None,
+        existence_status: bool | None = None,
+        full_name: str | None = None
     ):
         self.lg_attack_step = lg_attack_step
         self.name = lg_attack_step.name
@@ -68,12 +69,10 @@ class AttackGraphNode:
 
         return node_dict
 
-
     def __repr__(self) -> str:
         return (f'AttackGraphNode(name: "{self.full_name}", id: {self.id}, '
             f'type: {self.type})')
 
-
     def __deepcopy__(self, memo) -> AttackGraphNode:
         """Deep copy an attackgraph node
 
@@ -83,15 +82,14 @@ class AttackGraphNode:
         should be recreated when deepcopying the attack graph itself.
 
         """
-
         # Check if the object is already in the memo dictionary
         if id(self) in memo:
             return memo[id(self)]
 
         copied_node = AttackGraphNode(
-            node_id = self.id,
-            model_asset = self.model_asset,
-            lg_attack_step = self.lg_attack_step
+            node_id=self.id,
+            model_asset=self.model_asset,
+            lg_attack_step=self.lg_attack_step
         )
 
         copied_node.tags = copy.deepcopy(self.tags, memo)
@@ -105,11 +103,9 @@ class AttackGraphNode:
 
         return copied_node
 
-
     @property
     def full_name(self) -> str:
-        """
-        Return the full name of the attack step. This is normally a
+        """Return the full name of the attack step. This is normally a
         combination of the asset name to which the attack step
         belongs and attack step name itself, but can also be
         explicitly set or a combination of the step id and step name.
@@ -117,7 +113,7 @@ class AttackGraphNode:
         if self._full_name:
             # Explicitly set
             return self._full_name
-        elif self.model_asset:
+        if self.model_asset:
             # Inherited from model asset
             full_name = self.model_asset.name + ':' + self.name
         else:
@@ -125,7 +121,6 @@ class AttackGraphNode:
             full_name = str(self.id) + ':' + self.name
         return full_name
 
-
     @cached_property
     def info(self) -> dict[str, str]:
         return self.lg_attack_step.info

maltoolbox/exceptions.py

@@ -1,14 +1,14 @@
 class MalToolboxException(Exception):
     """Base exception for all other maltoolbox exceptions to inherit from."""
-    pass
+
 
 class LanguageGraphException(MalToolboxException):
     """Base exception for all language-graph related exceptions."""
-    pass
+
 
 class LanguageGraphSuperAssetNotFoundError(LanguageGraphException):
     """Asset's super asset not found in language graph during attack graph construction."""
-    pass
+
 
 class LanguageGraphAssociationError(LanguageGraphException):
     """Error in building an association.
@@ -16,30 +16,27 @@ class LanguageGraphAssociationError(LanguageGraphException):
     For example, right or left-hand side asset of association missing in
     language graph.
     """
-    pass
+
 
 class LanguageGraphStepExpressionError(LanguageGraphException):
     """A target asset cannot be linked with for a step expression."""
-    pass
+
 
 class AttackGraphException(MalToolboxException):
     """Base exception for all attack-graph related exceptions."""
-    pass
+
 
 class AttackGraphStepExpressionError(AttackGraphException):
     """A target attack step cannot be linked with for a step expression."""
-    pass
 
 
 class ModelException(MalToolboxException):
     """Base Exception for all Model related exceptions"""
-    pass
 
 
 class ModelAssociationException(ModelException):
     """Exception related to associations in Model"""
-    pass
+
 
 class DuplicateModelAssociationError(ModelException):
     """Associations should be unique as part of Model"""
-    pass

maltoolbox/file_utils.py

@@ -1,16 +1,19 @@
 """Utilty functions for file handling"""
 
 import json
+
 import yaml
 
+
 def save_dict_to_json_file(filename: str, serialized_object: dict) -> None:
     """Save serialized object to a json file.
 
     Arguments:
+    ---------
     filename        - the name of the output file
     data            - dict to output as json
-    """
 
+    """
     with open(filename, 'w', encoding='utf-8') as f:
         json.dump(serialized_object, f, indent=4)
 
@@ -19,8 +22,10 @@ def save_dict_to_yaml_file(filename: str, serialized_object: dict) -> None:
     """Save serialized object to a yaml file.
 
     Arguments:
+    ---------
     filename        - the name of the output file
     data            - dict to output as yaml
+
     """
 
     class NoAliasSafeDumper(yaml.SafeDumper):
@@ -33,14 +38,14 @@ def save_dict_to_yaml_file(filename: str, serialized_object: dict) -> None:
 
 def load_dict_from_yaml_file(filename: str) -> dict:
     """Open json file and read as dict"""
-    with open(filename, 'r', encoding='utf-8') as file:
+    with open(filename, encoding='utf-8') as file:
         object_dict = yaml.safe_load(file)
     return object_dict
 
 
 def load_dict_from_json_file(filename: str) -> dict:
     """Open yaml file and read as dict"""
-    with open(filename, 'r', encoding='utf-8') as file:
+    with open(filename, encoding='utf-8') as file:
         object_dict = json.loads(file.read())
     return object_dict
 
@@ -50,10 +55,11 @@ def save_dict_to_file(filename: str, dictionary: dict) -> None:
     depending on file extension.
 
     Arguments:
+    ---------
     filename        - the name of the output file
     dictionary      - the dict to save to the file
-    """
 
+    """
     if filename.endswith(('.yml', '.yaml')):
         save_dict_to_yaml_file(filename, dictionary)
     elif filename.endswith('.json'):

maltoolbox/language/__init__.py

@@ -20,4 +20,4 @@ __all__ = [
     "LanguageGraphAssociation",
     "LanguageGraphAttackStep",
     "disaggregate_attack_step_full_name"
-]
+]

maltoolbox/language/compiler/__init__.py

@@ -3,7 +3,7 @@ import sys
 from collections.abc import MutableMapping, MutableSequence
 from pathlib import Path
 
-from antlr4 import FileStream, CommonTokenStream, ParseTreeVisitor
+from antlr4 import CommonTokenStream, FileStream, ParseTreeVisitor
 from antlr4.error.ErrorListener import ConsoleErrorListener
 
 from .mal_lexer import malLexer
@@ -16,7 +16,7 @@ from .mal_parser import malParser
 
 def patched_antrl_syntax_error(self, recognizer, offendingSymbol, line, column, msg, e):
     file = patched_antrl_syntax_error.file
-    print(f"{file}:{str(line)}:{str(column)}: {msg}", file=sys.stderr)
+    print(f"{file}:{line!s}:{column!s}: {msg}", file=sys.stderr)
 
 
 ConsoleErrorListener.syntaxError = patched_antrl_syntax_error
@@ -88,9 +88,9 @@ class MalCompiler(ParseTreeVisitor):
                     included_file = self.compile(value)
                     for k, v in langspec.items():
                         if isinstance(v, MutableMapping):
-                            langspec[k].update(included_file.get(k, {}))
+                            v.update(included_file.get(k, {}))
                         if isinstance(v, MutableSequence) and k in included_file:
-                            langspec[k].extend(included_file[k])
+                            v.extend(included_file[k])
 
         for key in ("categories", "assets", "associations"):
             unique = []