Merge 7a832ca into 89cd493

CONTRIBUTING.md

@@ -12,15 +12,15 @@
 
 To confirm these system dependencies are configured correctly:
 
-```sh
+```text
 $ make doctor
 ```
 
 ## Installation
 
 Install project dependencies into a virtual environment:
 
-```sh
+```text
 $ make install
 ```
 
@@ -30,27 +30,27 @@ $ make install
 
 Run the tests:
 
-```sh
+```text
 $ make test
 ```
 
 Run static analysis:
 
-```sh
+```text
 $ make check
 ```
 
 Build the documentation:
 
-```sh
+```text
 $ make docs
 ```
 
 ## Automatic
 
 Keep all of the above tasks running on change:
 
-```sh
+```text
 $ make watch
 ```
 
@@ -60,14 +60,14 @@ $ make watch
 
 The CI server will report overall build status:
 
-```sh
+```text
 $ make ci
 ```
 
 # Release Tasks
 
 Release to PyPI:
 
-```sh
+```text
 $ make upload
 ```

datafiles/decorators.py

@@ -2,14 +2,16 @@
 from typing import Dict, Optional
 
 from .converters import Converter
-from .models import create_model
+from .models import ModelMeta, create_model
 
 
 def datafile(
     pattern: str,
     attrs: Optional[Dict[str, Converter]] = None,
-    manual: bool = False,
-    defaults: bool = False,
+    manual: bool = ModelMeta.datafile_manual,
+    defaults: bool = ModelMeta.datafile_defaults,
+    auto_load: bool = ModelMeta.datafile_auto_load,
+    auto_save: bool = ModelMeta.datafile_auto_save,
 ):
     """Synchronize a data class to the specified path."""
 
@@ -20,7 +22,13 @@ def decorator(cls):
             dataclass = dataclasses.dataclass(cls)
 
         return create_model(
-            dataclass, attrs=attrs, pattern=pattern, manual=manual, defaults=defaults
+            dataclass,
+            attrs=attrs,
+            pattern=pattern,
+            manual=manual,
+            defaults=defaults,
+            auto_load=auto_load,
+            auto_save=auto_save,
         )
 
     return decorator

datafiles/hooks.py

@@ -83,10 +83,8 @@ def wrapped(self, *args, **kwargs):
             if datafile.exists and datafile.modified:
                 log.debug(f"Loading automatically before '{method.__name__}' call")
                 datafile.load()
-                # TODO: Implement this?
-                # if mapper.auto_save_after_load:
-                #     mapper.save()
-                #     mapper.modified = False
+                if datafile.auto_save:
+                    datafile.save(_log=False)
 
         return method(self, *args, **kwargs)
 
@@ -117,6 +115,8 @@ def wrapped(self, *args, **kwargs):
         if enabled(datafile, args):
             log.debug(f"Saving automatically after '{method.__name__}' call")
             datafile.save()
+            if datafile.auto_load:
+                datafile.load(_log=False)
 
         return result
 

datafiles/managers.py

@@ -34,6 +34,8 @@ def __init__(
         pattern: Optional[str],
         manual: bool,
         defaults: bool,
+        auto_load: bool,
+        auto_save: bool,
         root: Optional[InstanceManager] = None,
     ) -> None:
         assert manual is not None
@@ -43,6 +45,8 @@ def __init__(
         self._pattern = pattern
         self._manual = manual
         self.defaults = defaults
+        self._auto_load = auto_load
+        self._auto_save = auto_save
         self._last_load = 0.0
         self._last_data: Dict = {}
         self._root = root
@@ -95,6 +99,14 @@ def modified(self, modified: bool):
     def manual(self) -> bool:
         return self._root.manual if self._root else self._manual
 
+    @property
+    def auto_load(self) -> bool:
+        return self._root.auto_load if self._root else self._auto_load
+
+    @property
+    def auto_save(self) -> bool:
+        return self._root.auto_save if self._root else self._auto_save
+
     @property
     def data(self) -> Dict:
         return self._get_data()
@@ -156,13 +168,14 @@ def _get_text(self, **kwargs) -> str:
             return formats.serialize(data, self.path.suffix)
         return formats.serialize(data)
 
-    def load(self, *, first_load=False) -> None:
+    def load(self, *, _log=True, _first=False) -> None:
         if self._root:
-            self._root.load(first_load=first_load)
+            self._root.load(_log=_log, _first=_first)
             return
 
         if self.path:
-            log.info(f"Loading '{self.classname}' object from '{self.relpath}'")
+            if _log:
+                log.info(f"Loading '{self.classname}' object from '{self.relpath}'")
         else:
             raise RuntimeError("'pattern' must be set to load the model")
 
@@ -179,7 +192,7 @@ def load(self, *, first_load=False) -> None:
                 if getattr(converter, 'DATACLASS', None):
                     self._set_dataclass_value(data, name, converter)
                 else:
-                    self._set_attribute_value(data, name, converter, first_load)
+                    self._set_attribute_value(data, name, converter, _first)
 
         self.modified = False
 
@@ -228,7 +241,7 @@ def _set_attribute_value(self, data, name, converter, first_load):
 
         if first_load:
             log.debug(
-                'First load values: file=%r, init=%r, default=%r',
+                'Initial load values: file=%r, init=%r, default=%r',
                 file_value,
                 init_value,
                 default_value,
@@ -263,13 +276,14 @@ def _get_default_field_value(self, name):
 
         return Missing
 
-    def save(self, include_default_values: Trilean = None) -> None:
+    def save(self, *, include_default_values: Trilean = None, _log=True) -> None:
         if self._root:
-            self._root.save(include_default_values=include_default_values)
+            self._root.save(include_default_values=include_default_values, _log=_log)
             return
 
         if self.path:
-            log.info(f"Saving '{self.classname}' object to '{self.relpath}'")
+            if _log:
+                log.info(f"Saving '{self.classname}' object to '{self.relpath}'")
         else:
             raise RuntimeError(f"'pattern' must be set to save the model")
 

datafiles/models.py

@@ -17,6 +17,8 @@ class ModelMeta:
 
     datafile_manual: bool = False
     datafile_defaults: bool = False
+    datafile_auto_load: bool = True
+    datafile_auto_save: bool = True
 
 
 class Model:
@@ -37,7 +39,7 @@ def __post_init__(self):
                 log.debug(f'Datafile exists: {exists}')
 
                 if exists:
-                    self.datafile.load(first_load=True)
+                    self.datafile.load(_first=True)
                 elif path:
                     self.datafile.save()
 
@@ -59,8 +61,10 @@ def build_datafile(obj, root=None) -> InstanceManager:
     m = getattr(obj, 'Meta', None)
     pattern = getattr(m, 'datafile_pattern', None)
     attrs = getattr(m, 'datafile_attrs', None)
-    manual = getattr(m, 'datafile_manual', False)
-    defaults = getattr(m, 'datafile_defaults', False)
+    manual = getattr(m, 'datafile_manual', ModelMeta.datafile_manual)
+    defaults = getattr(m, 'datafile_defaults', ModelMeta.datafile_defaults)
+    auto_load = getattr(m, 'datafile_auto_load', ModelMeta.datafile_auto_load)
+    auto_save = getattr(m, 'datafile_auto_save', ModelMeta.datafile_auto_save)
 
     if attrs is None and dataclasses.is_dataclass(obj):
         attrs = {}
@@ -71,11 +75,27 @@ def build_datafile(obj, root=None) -> InstanceManager:
                 attrs[field.name] = map_type(field.type)
 
     return InstanceManager(
-        obj, attrs=attrs, pattern=pattern, manual=manual, defaults=defaults, root=root
+        obj,
+        attrs=attrs,
+        pattern=pattern,
+        manual=manual,
+        defaults=defaults,
+        auto_load=auto_load,
+        auto_save=auto_save,
+        root=root,
     )
 
 
-def create_model(cls, *, attrs=None, pattern=None, manual=None, defaults=None):
+def create_model(
+    cls,
+    *,
+    attrs=None,
+    pattern=None,
+    manual=None,
+    defaults=None,
+    auto_load=None,
+    auto_save=None,
+):
     """Patch datafile attributes on to an existing dataclass."""
     log.debug(f'Converting {cls} to a datafile model')
 
@@ -95,6 +115,10 @@ def create_model(cls, *, attrs=None, pattern=None, manual=None, defaults=None):
         m.datafile_manual = manual
     if not hasattr(cls, 'Meta') and defaults is not None:
         m.datafile_defaults = defaults
+    if not hasattr(cls, 'Meta') and auto_load is not None:
+        m.datafile_auto_load = auto_load
+    if not hasattr(cls, 'Meta') and auto_save is not None:
+        m.datafile_auto_save = auto_save
 
     cls.Meta = m
 

datafiles/tests/test_managers.py

@@ -6,6 +6,7 @@
 import pytest
 
 from datafiles import managers
+from datafiles.models import ModelMeta
 
 
 @dataclass
@@ -26,8 +27,10 @@ def manager():
             instance=MyModel(foobar=42),
             attrs={},
             pattern=None,
-            manual=False,
-            defaults=False,
+            manual=ModelMeta.datafile_manual,
+            defaults=ModelMeta.datafile_defaults,
+            auto_load=ModelMeta.datafile_auto_load,
+            auto_save=ModelMeta.datafile_auto_save,
         )
 
     def describe_path():

docs/index.md

@@ -6,13 +6,13 @@ Datafiles is a bidirectional serialization library for Python [dataclasses](http
 
 Install it directly into an activated virtual environment:
 
-```
+```text
 $ pip install datafiles
 ```
 
 or add it to your [Poetry](https://poetry.eustace.io/) project:
 
-```
+```text
 $ poetry add datafiles
 ```