Further refinement

Author: clittle

layers/README.md

@@ -23,10 +23,12 @@ The Layer class provides format validation and read/write capabilities to aid in
 
 | method [x = Layer()]| description |
 |:-------|:------------|
-| x.load_input(_input_) | Loads an ATT&CK layer from either a dictionary or a string representation of a dictionary. |
-| x.load_file(_input_) | Loads an ATT&CK layer from a file location specified by the _input_. |
-| x.export_file(_input_) | Saves the current state of the loaded ATT&CK layer to a json file denoted by the _input_. |
-| x.get_dict() | Returns a representation of the current ATT&CK layer object as a dictionary. | 
+| x.from_str(_input_) | Loads an ATT&CK layer from either a string representation of a dictionary. |
+| x.from_dict(_input_) | Loads an ATT&CK layer from either a dictionary. |
+| x.from_file(_input_) | Loads an ATT&CK layer from a file location specified by the _input_. |
+| x.to_file(_input_) | Saves the current state of the loaded ATT&CK layer to a json file denoted by the _input_. |
+| x.to_dict() | Returns a representation of the current ATT&CK layer object as a dictionary. |
+| x.to_str() | Returns a representation of the current ATT&CK layer object as a string representation of a dictionary. | 
 
 #### Example Usage
 
@@ -43,14 +45,14 @@ example_layer_out_location = "/path/to/new/layer/file.json"
 from layers.core import Layer
 
 layer1 = Layer(example_layer_dict)              # Create a new layer and load existing data
-layer1.export_file(example_layer_out_location)  # Write out the loaded layer to the specified file
+layer1.to_file(example_layer_out_location)  # Write out the loaded layer to the specified file
 
 layer2 = Layer()                                # Create a new layer object
-layer2.load_input(example_layer_dict)           # Load layer data into existing layer object
-print(layer2.get_dict())                        # Retrieve the loaded layer's data as a dictionary, and print it
+layer2.from_dict(example_layer_dict)           # Load layer data into existing layer object
+print(layer2.to_dict())                        # Retrieve the loaded layer's data as a dictionary, and print it
 
 layer3 = Layer()                                # Create a new layer object
-layer3.load_file(example_layer_location)        # Load layer data from a file into existing layer object
+layer3.from_file(example_layer_location)        # Load layer data from a file into existing layer object
 ```
 
 ## layerops.py
@@ -65,47 +67,48 @@ Layerops.py provides the LayerOps class, which is a way to combine layer files i
 
 ##### .process() Method
 ```python
-x.process(data, defaults=defaults)
+x.process(data, default_values=default_values)
 ```
-The process method applies the lambda functions stored during initialization to the layer objects in _data_. _data_ must be either a list or a dictionary of Layer objects, and is expected to match the format of the lambda equations provided during initialization.
+The process method applies the lambda functions stored during initialization to the layer objects in _data_. _data_ must be either a list or a dictionary of Layer objects, and is expected to match the format of the lambda equations provided during initialization. default_values is an optional dictionary argument that overrides the currently stored default
+ values with new ones for this specific processing operation.
 
 #### Example Usage
 ```python
 from layers.manipulators.layerops import LayerOps
 from layers.core.layer import Layer
 
 demo = Layer()
-demo.load_file("C:\Users\attack\Downloads\layer.json")
+demo.from_file("C:\Users\attack\Downloads\layer.json")
 demo2 = Layer()
-demo2.load_file("C:\Users\attack\Downloads\layer2.json")
+demo2.from_file("C:\Users\attack\Downloads\layer2.json")
 demo3 = Layer()
-demo3.load_file("C:\Users\attack\Downloads\layer3.json")
+demo3.from_file("C:\Users\attack\Downloads\layer3.json")
 
 # Example 1) Build a LayerOps object that takes a list and averages scores across the layers
 lo = LayerOps(score=lambda x: sum(x) / len(x), 
               name=lambda x: x[1], 
               desc=lambda x: "This is an list example")     # Build LayerOps object
 out_layer = lo.process([demo, demo2])                       # Trigger processing on a list of demo and demo2 layers
-out_layer.export_file("C:\demo_layer1.json")                # Save averaged layer to file
+out_layer.to_file("C:\demo_layer1.json")                    # Save averaged layer to file
 out_layer2 = lo.process([demo, demo2, demo3])               # Trigger processing on a list of demo, demo2, demo3
-visual_aid = out_layer2.get_dict("C:\demo_layer2.json")     # Retrieve dictionary representation of processed layer
+visual_aid = out_layer2.to_dict()                           # Retrieve dictionary representation of processed layer
 
 # Example 2) Build a LayerOps object that takes a dictionary and averages scores across the layers
 lo2 = LayerOps(score=lambda x: sum([x[y] for y in x]) / len([x[y] for y in x]), 
                color=lambda x: x['b'], 
                desc=lambda x: "This is a dict example")      # Build LayerOps object, with lambda
 out_layer3 = lo2.process({'a': demo, 'b': demo2})            # Trigger processing on a dictionary of demo and demo2
-dict_layer = out_layer3.get_dict()                           # Retrieve dictionary representation of processed layer
+dict_layer = out_layer3.to_dict()                            # Retrieve dictionary representation of processed layer
 print(dict_layer)                                            # Display retrieved dictionary
 out_layer4 = lo2.process({'a': demo, 'b': demo2, 'c': demo3})# Trigger processing on a dictionary of demo, demo2, demo3
-out_layer4.export_file("C:\demo_layer4.json")                # Save averaged layer to file
+out_layer4.to_file("C:\demo_layer4.json")                    # Save averaged layer to file
 
 # Example 3) Build a LayerOps object that takes a single element dictionary and inverts the score
 lo3 = LayerOps(score=lambda x: 100 - x['a'],
                desc= lambda x: "This is a simple example")  # Build LayerOps object to invert score (0-100 scale)
 out_layer5 = lo3.process({'a': demo})                       # Trigger processing on dictionary of demo
-print(out_layer5.get_dict())                                # Display processed layer in dictionary form
-out_layer5.export_file("C:\demo_layer5.json")               # Save inverted score layer to file
+print(out_layer5.to_dict())                                 # Display processed layer in dictionary form
+out_layer5.to_file("C:\demo_layer5.json")                   # Save inverted score layer to file
 
 # Example 4) Build a LayerOps object that combines the comments from elements in the list, with custom defaults
 lo4 = LayerOps(score=lambda x: '; '.join(x),
@@ -114,5 +117,5 @@ lo4 = LayerOps(score=lambda x: '; '.join(x),
                 },
                desc= lambda x: "This is a defaults example")  # Build LayerOps object to combine descriptions, defaults
 out_layer6 = lo4.process([demo2, demo3])                      # Trigger processing on a list of demo2 and demo0
-out_layer6.export_file("C:\demo_layer6.json")                 # Save combined comment layer to file
+out_layer6.to_file("C:\demo_layer6.json")                     # Save combined comment layer to file
 ```

layers/core/__init__.py

@@ -0,0 +1,10 @@
+from .layer import Layer
+from .exceptions import *
+from .filter import Filter
+from .gradient import Gradient
+from .layerobj import _LayerObj
+from .layout import Layout
+from .legenditem import LegendItem
+from .metadata import Metadata
+from .technique import Technique
+

layers/core/layer.py

@@ -5,46 +5,55 @@
 
 
 class Layer:
-    def __init__(self, init_dict={}, strict=True):
+    def __init__(self, init_data={}, strict=True):
         """
              Initialization - create a new Layer object
              :param init_dict: Optionally provide base Layer json or string
                 data on initialization
          """
         self.__layer = None
         self.strict = strict
-        self.load_input(init_dict)
+        if isinstance(init_data, str):
+            self.from_str(init_data)
+        else:
+            self.from_dict(init_data)
 
     @property
     def layer(self):
         if self.__layer is not None:
             return self.__layer
         return "No Layer Loaded Yet!"
 
-    def load_input(self, init_dict):
+    def from_str(self, init_str):
         """
-            loads input from a string or dictionary format
-            :param init_dit: the string or dictionary representing the layer
-                data to be loaded
+            Loads a raw layer string into the object
+            :param init_str: the string representing the layer data to
+                be loaded
         """
-        if isinstance(init_dict, str):
-            self.data = json.loads(init_dict)
-        else:
-            self.data = init_dict
-        if self.data != {}:
+        self._data = json.loads(init_str)
+        self._build()
+
+    def from_dict(self, init_dict):
+        """
+            Loads a raw layer string into the object
+            :param init_dict: the dictionary representing the layer data to
+                be loaded
+        """
+        self._data = init_dict
+        if self._data != {}:
             self._build()
 
-    def load_file(self, filename):
+    def from_file(self, filename):
         """
              loads input from a layer file specified by filename
              :param filename: the target filename to load from
         """
         with open(filename, 'r') as fio:
             raw = fio.read()
-            self.data = json.load(raw)
+            self._data = json.loads(raw)
             self._build()
 
-    def export_file(self, filename):
+    def to_file(self, filename):
         """
             saves the current state of the layer to a layer file specified by
                 filename
@@ -61,8 +70,8 @@ def _build(self):
             Loads the data stored in self.data into a LayerObj (self.layer)
         """
         try:
-            self.__layer = _LayerObj(self.data['version'], self.data['name'],
-                                    self.data['domain'])
+            self.__layer = _LayerObj(self._data['version'], self._data['name'],
+                                    self._data['domain'])
         except BadType or BadInput as e:
             handler(type(self).__name__, 'Layer is malformed: {}. '
                                          'Unable to load.'.format(e))
@@ -74,10 +83,10 @@ def _build(self):
             self.__layer = None
             return
 
-        for key in self.data:
+        for key in self._data:
             if key not in ['version', 'name', 'domain']:
                 try:
-                    self.__layer._linker(key, self.data[key])
+                    self.__layer._linker(key, self._data[key])
                 except Exception as e:
                     if self.strict:
                         handler(type(self).__name__, "{} error. "
@@ -86,10 +95,19 @@ def _build(self):
                         self.__layer = None
                         return
 
-    def get_dict(self):
+    def to_dict(self):
         """
             Converts the currently loaded layer file into a dict
             :returns: A dict representation of the current layer object
         """
         if self.__layer is not None:
             return self.__layer.get_dict()
+
+    def to_str(self):
+        """
+            Converts the currently loaded layer file into a string
+                representation of a dictionary
+            :returns: A string representation of the current layer object
+        """
+        if self.__layer is not None:
+            return json.dumps(self.to_dict())

layers/manipulators/layerops.py

@@ -50,14 +50,14 @@ def __init__(self, score=None, comment=None, enabled=None, colors=None,
             :param default_values: dictionary containing desired default
                 values for missing data element values
         """
-        self.score = score
-        self.comment = comment
-        self.enabled = enabled
-        self.colors = colors
-        self.metadata = metadata
-        self.name = name
-        self.desc = desc
-        self.default_values = {
+        self._score = score
+        self._comment = comment
+        self._enabled = enabled
+        self._colors = colors
+        self._metadata = metadata
+        self._name = name
+        self._desc = desc
+        self._default_values = {
             "comment": "",
             "enabled": True,
             "color": "#ffffff",
@@ -66,13 +66,13 @@ def __init__(self, score=None, comment=None, enabled=None, colors=None,
         }
         if default_values is not None:
             for entry in default_values:
-                self.default_values[entry] = default_values[entry]
+                self._default_values[entry] = default_values[entry]
 
-    def process(self, data, defaults=None):
+    def process(self, data, default_values=None):
         """
             takes a list or dict of Layer objects, and processes them
             :param data: A dict or list of Layer objects.
-            :param defaults: dictionary containing desired default values for
+            :param default_values: dictionary containing desired default values for
                 missing data element values
             :raises InvalidFormat: An error indicating that the layer data
                 wasn't provided in a list or dict
@@ -94,8 +94,10 @@ def process(self, data, defaults=None):
         da = temp
         corpus = self._build_template(temp)
 
-        if defaults is not None:
-            defaults = self.default_values
+        defaults = self._default_values
+        if default_values is not None:
+            for entry in default_values:
+                defaults[entry] = default_values[entry]
 
         return self._compute(data, da, corpus, out, defaults)
 
@@ -113,43 +115,43 @@ def _compute(self, data, da, corpus, out, defaults):
             :returns: a Layer object representing the resultant layer
         """
         composite = copy.deepcopy(corpus)
-        if self.score is not None:
+        if self._score is not None:
             for entry in composite:
                 entry['score'] = self._applyOperation(da, entry, 'score',
-                                                      self.score, defaults)
+                                                      self._score, defaults)
 
-        if self.comment is not None:
+        if self._comment is not None:
             for entry in composite:
                 entry['comment'] = self._applyOperation(da, entry, 'comment',
-                                                        self.comment, defaults)
+                                                        self._comment, defaults)
 
-        if self.enabled is not None:
+        if self._enabled is not None:
             for entry in composite:
                 entry['enabled'] = self._applyOperation(da, entry, 'enabled',
-                                                        self.enabled, defaults)
+                                                        self._enabled, defaults)
 
-        if self.colors is not None:
+        if self._colors is not None:
             for entry in composite:
                 entry['color'] = self._applyOperation(da, entry, 'color',
-                                                      self.colors, defaults)
+                                                      self._colors, defaults)
 
-        if self.metadata is not None:
+        if self._metadata is not None:
             for entry in composite:
                 entry['metadata'] = self._applyOperation(da, entry, 'metadata',
-                                                         self.metadata,
+                                                         self._metadata,
                                                          defaults)
 
         processed = copy.deepcopy(out)
         processed['techniques'] = composite
-        if self.name is not None:
+        if self._name is not None:
             processed['name'] = self._applyOperation(data, None, 'name',
-                                                     self.name, defaults,
+                                                     self._name, defaults,
                                                      glob='name')
 
-        if self.desc is not None:
+        if self._desc is not None:
             processed['description'] = self._applyOperation(data, None,
                                                             'description',
-                                                            self.desc,
+                                                            self._desc,
                                                             defaults,
                                                             glob='description')
 
@@ -310,7 +312,7 @@ def _applyOperation(self, corpus, element, name, lda, defaults, glob=None):
                         if name in defaults:
                             values.append(defaults[name])
                             continue
-                    values.append(self.default_values[name])
+                    values.append(self._default_values[name])
         else:
             values = {}
             if glob:
@@ -333,7 +335,7 @@ def _applyOperation(self, corpus, element, name, lda, defaults, glob=None):
                         if name in defaults:
                             values[elm] = defaults[name]
                             continue
-                    values[elm] = self.default_values[name]
+                    values[elm] = self._default_values[name]
         try:
             return lda(values)
         except IndexError and KeyError: