model: Simplified Model API with SimpleModel

Signed-off-by: John Andersen <[email protected]>

Author: pdxjohnny

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Doctestable Examples to high-level API.
 - Shouldi got an operation to run npm-audit on JavaScript code
 - Docstrings and doctestable examples for `record.py` (features and evaluated)
+- Simplified model API with SimpleModel
 ### Changed
 - Restructured contributing documentation
 - Use randomly generated data for scikit tests

dffml/__init__.py

@@ -9,7 +9,7 @@
 from .source.json import JSONSource
 
 # Models
-from .model import Model, ModelContext
+from .model import Model, ModelContext, SimpleModel, ModelNotTrained
 
 # Utilities
 from .util.asynctestcase import AsyncTestCase

dffml/model/__init__.py

@@ -15,4 +15,4 @@
 >>>     },
 >>> )
 """
-from .model import Model, ModelContext
+from .model import Model, ModelContext, SimpleModel, ModelNotTrained

dffml/model/model.py

@@ -7,7 +7,10 @@
 """
 import os
 import abc
-from typing import AsyncIterator
+import json
+import hashlib
+import pathlib
+from typing import AsyncIterator, Optional
 
 from ..base import (
     config,
@@ -82,3 +85,119 @@ def __call__(self) -> ModelContext:
         if directory is not None and not os.path.isdir(directory):
             os.makedirs(directory)
         return self.CONTEXT(self)
+
+
+class SimpleModelNoContext:
+    """
+    No need for CONTEXT since we implement __call__
+    """
+
+
+class SimpleModel(Model):
+    DTYPES = [int, float]
+    NUM_SUPPORTED_FEATURES = -1
+    SUPPORTED_LENGTHS = None
+    CONTEXT = SimpleModelNoContext
+
+    def __init__(self, config: "BaseConfig") -> None:
+        super().__init__(config)
+        self.storage = {}
+        self.features = self.applicable_features(config.features)
+        self._in_context = 0
+
+    def __call__(self):
+        return self
+
+    async def __aenter__(self) -> Model:
+        self._in_context += 1
+        # If we've already entered the model's context once, don't reload
+        if self._in_context > 1:
+            return self
+        self.open()
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        self._in_context -= 1
+        if not self._in_context:
+            self.close()
+
+    def open(self):
+        """
+        Load saved model from disk if it exists.
+        """
+        # Load saved data if this is the first time we've entred the model
+        filepath = self.disk_path(extention=".json")
+        if filepath.is_file():
+            self.storage = json.loads(filepath.read_text())
+            self.logger.debug("Loaded model from %s", filepath)
+        else:
+            self.logger.debug("No saved model in %s", filepath)
+
+    def close(self):
+        """
+        Save model to disk.
+        """
+        filepath = self.disk_path(extention=".json")
+        filepath.write_text(json.dumps(self.storage))
+        self.logger.debug("Saved model to %s", filepath)
+
+    def disk_path(self, extention: Optional[str] = None):
+        """
+        We do this for convenience of the user so they can usually just use the
+        default directory and if they train models with different parameters
+        this method transparently to the user creates a filename unique the that
+        configuration of the model where data is saved and loaded.
+        """
+        # Export the config to a dictionary
+        exported = self.config._asdict()
+        # Remove the directory from the exported dict
+        if "directory" in exported:
+            del exported["directory"]
+        # Replace features with the sorted list of features
+        if "features" in exported:
+            exported["features"] = dict(sorted(exported["features"].items()))
+        # Hash the exported config
+        return pathlib.Path(
+            self.config.directory,
+            hashlib.sha384(json.dumps(exported).encode()).hexdigest()
+            + (extention if extention else ""),
+        )
+
+    def applicable_features(self, features):
+        usable = []
+        # Check that we aren't trying to use more features than the model
+        # supports
+        if (
+            self.NUM_SUPPORTED_FEATURES != -1
+            and len(features) != self.NUM_SUPPORTED_FEATURES
+        ):
+            msg = f"{self.__class__.__qualname__} doesn't support more than "
+            if self.NUM_SUPPORTED_FEATURES == 1:
+                msg += f"{self.NUM_SUPPORTED_FEATURES} feature"
+            else:
+                msg += f"{self.NUM_SUPPORTED_FEATURES} features"
+            raise ValueError(msg)
+        # Check data type and length for each feature
+        for feature in features:
+            if self.check_applicable_feature(feature):
+                usable.append(feature.NAME)
+        # Return a sorted list of feature names for consistency. In case users
+        # provide the same list of features to applicable_features in a
+        # different order.
+        return sorted(usable)
+
+    def check_applicable_feature(self, feature):
+        # Check the data datatype is in the list of supported data types
+        if feature.dtype() not in self.DTYPES:
+            msg = f"{self.__class__.__qualname__} only supports features "
+            msg += f"with these data types: {self.DTYPES}"
+            raise ValueError(msg)
+        # If SUPPORTED_LENGTHS is None then all lengths are supported
+        if self.SUPPORTED_LENGTHS is None:
+            return True
+        # Check that length (dimensions) of feature is supported
+        if feature.length() not in self.SUPPORTED_LENGTHS:
+            msg = f"{self.__class__.__qualname__} only supports "
+            msg += f"{self.SUPPORTED_LENGTHS} dimensional values"
+            raise ValueError(msg)
+        return True