Merge pull request #294 from bnorick/fronzen-dataclasses

Adds support for frozen dataclasses with some tests

datafiles/manager.py

@@ -69,7 +69,7 @@ def get(self, *args, **kwargs) -> Model:
                         value = field.default_factory()
                     else:
                         value = Missing
-                setattr(instance, field.name, value)
+                object.__setattr__(instance, field.name, value)
 
             # NOTE: the following doesn't call instance.datafile.load because hooks are disabled currently
             model.Model.__post_init__(instance)

datafiles/mapper.py

@@ -33,6 +33,10 @@ def __init__(
         assert manual is not None
         assert defaults is not None
         self._instance = instance
+        self._frozen = (
+            dataclasses.is_dataclass(self._instance)
+            and self._instance.__dataclass_params__.frozen
+        )
         self.attrs = attrs
         self._pattern = pattern
         self._manual = manual
@@ -162,6 +166,11 @@ def _get_text(self, **kwargs) -> str:
         return formats.serialize(data)
 
     def load(self, *, _log=True, _first_load=False) -> None:
+        if self._frozen and not _first_load:
+            raise dataclasses.FrozenInstanceError(
+                "Cannot load frozen dataclass instances more than once."
+            )
+
         if self._root:
             self._root.load(_log=_log, _first_load=_first_load)
             return
@@ -248,14 +257,19 @@ def _set_value(instance, name, converter, data, first_load):
             value = converter.to_python_value(file_value, target_object=init_value)
 
         log.debug(f"Setting '{name}' value: {value!r}")
-        setattr(instance, name, value)
+        object.__setattr__(instance, name, value)
 
     def save(self, *, include_default_values: Trilean = None, _log=True) -> None:
         if self._root:
             self._root.save(include_default_values=include_default_values, _log=_log)
             return
 
         if self.path:
+            if self.exists and self._frozen:
+                raise dataclasses.FrozenInstanceError(
+                    f"Cannot save frozen dataclass instances which already exist, "
+                    f"delete '{self.path}' before saving."
+                )
             if _log:
                 log.info(f"Saving '{self.classname}' object to '{self.relpath}'")
         else:

datafiles/model.py

@@ -5,17 +5,19 @@
 
 from . import config, hooks, settings
 from .manager import Manager
-from .mapper import create_mapper
+from .mapper import Mapper, create_mapper
 
 
 class Model:
 
     Meta: config.Meta = config.Meta()
+    datafile: Mapper
 
     def __post_init__(self):
         log.debug(f"Initializing {self.__class__} object")
 
-        self.datafile = create_mapper(self)
+        # Using object.__setattr__ in case of frozen dataclasses
+        object.__setattr__(self, "datafile", create_mapper(self))
 
         if settings.HOOKS_ENABLED:
             with hooks.disabled():

datafiles/tests/test_model.py

@@ -1,4 +1,5 @@
 # pylint: disable=unused-variable
+import dataclasses
 
 from datafiles import model
 
@@ -10,3 +11,12 @@ class NonDataclass:
 
         with expect.raises(ValueError):
             model.create_model(NonDataclass)
+
+    def it_is_compatible_with_frozen_dataclass(expect):
+        @dataclasses.dataclass(frozen=True)
+        class FrozenDataclass:
+            a: int
+
+        frozen_model = model.create_model(FrozenDataclass)
+        expect(hasattr(frozen_model, "Meta")).is_(True)
+        expect(hasattr(frozen_model, "objects")).is_(True)

tests/samples.py

@@ -13,6 +13,14 @@ class Sample:
     str_: str
 
 
+@datafile("../tmp/sample.yml", manual=True, frozen=True)
+class SampleFrozen:
+    bool_: bool
+    int_: int
+    float_: float
+    str_: str
+
+
 @datafile("../tmp/sample.json", manual=True)
 class SampleAsJSON:
     bool_: bool

tests/test_loading.py

@@ -2,7 +2,7 @@
 
 # pylint: disable=unused-variable
 
-from dataclasses import dataclass, field
+from dataclasses import FrozenInstanceError, dataclass, field
 
 import pytest
 
@@ -13,6 +13,7 @@
 from .samples import (
     Sample,
     SampleAsJSON,
+    SampleFrozen,
     SampleWithDefaults,
     SampleWithList,
     SampleWithListAndDefaults,
@@ -98,6 +99,34 @@ def with_invalid_data(sample, expect):
         expect(sample.int_) == 0
 
 
+def describe_frozen():
+    def with_already_loaded(expect):
+        write(
+            "tmp/sample.yml",
+            """
+            bool_: true
+            int_: 1
+            float_: 2.3
+            str_: 'foobar'
+            """,
+        )
+        # NOTE: To trigger a load with frozen dataclasses we can't simply
+        # use sample.datafile.load() because this will have _first_load=False
+        # and raise, and if we set _first_load=True then the None values
+        # would be taken as non-default init values and override the data
+        # from the file. Here, we use Manager.get to trigger the appropriate
+        # call to Mapper.load with no non-default init arguments.
+        sample = SampleFrozen.objects.get()
+
+        expect(sample.bool_).is_(True)
+        expect(sample.int_) == 1
+        expect(sample.float_) == 2.3
+        expect(sample.str_) == "foobar"
+
+        with expect.raises(FrozenInstanceError):
+            sample.datafile.load()
+
+
 def describe_alternate_formats():
     @pytest.fixture
     def sample():

tests/test_saving.py

@@ -2,6 +2,7 @@
 
 # pylint: disable=unused-variable,assigning-non-slot,unsubscriptable-object
 
+from dataclasses import FrozenInstanceError
 from typing import Optional
 
 import pytest
@@ -12,6 +13,7 @@
 from . import xfail_with_pep_563
 from .samples import (
     Sample,
+    SampleFrozen,
     SampleWithCustomFields,
     SampleWithDefaults,
     SampleWithList,
@@ -80,6 +82,22 @@ def with_custom_fields(expect):
             )
 
 
+def describe_frozen():
+    def with_already_existing(expect):
+        write(
+            "tmp/sample.yml",
+            """
+            bool_: true
+            int_: 1
+            float_: 2.3
+            str_: 'foobar'
+            """,
+        )
+        sample = SampleFrozen(True, 1, 2.3, "foobar")
+        with expect.raises(FrozenInstanceError):
+            sample.datafile.save()
+
+
 def describe_lists():
     def when_empty(expect):
         sample = SampleWithList([])