Merge pull request #5 from AFriemann/v2

V2

Author: Aljosha Friemann

README.v2.rst

@@ -26,6 +26,9 @@ to work:
 
     >>> from pprint import pprint
 
+*Note*: casting Data to a dict as it is done here is unnecessary as well. However pprint does not sort models in
+Python 2 without the cast for some reason.
+
 Examples:
 
 .. code:: python
@@ -184,10 +187,10 @@ To easily check against expected values you can use the helper function *one_of*
     >>> Data(foo='foo') # doctest: +ELLIPSIS +IGNORE_EXCEPTION_DETAIL
     Traceback (most recent call last):
         ...
-    ModelError: Data
-    - attribute: {'name': 'foo', 'type': ..., 'default': None, 'optional': False, 'mutable': True, 'alias': None, 'help': None, 'value': 'bar'}
+    simple_model.v2.ModelError: Data
+    - attribute: foo
       value: "foo"
-      exception: ('Invalid value for Attribute: foo', ValueError("must be one of ('bar', 'foobar') but was 'foo'",))
+      exception: must be one of ('bar', 'foobar') but was 'foo'
 
 If you want to disallow unknown values, set the *ignore_unknown* attribute to False
 
@@ -206,7 +209,7 @@ If you want to disallow unknown values, set the *ignore_unknown* attribute to Fa
       value: "def"
       exception: Unknown attribute "other"
 
-Models are immutable by default
+Models are mutable by default
 
 .. code:: python
 
@@ -216,16 +219,19 @@ Models are immutable by default
     ...     pass
 
     >>> d = Data(point = 1)
-    >>> d.point = 2  # doctest: +ELLIPSIS
-    Traceback (most recent call last):
-        ...
-    AttributeError: can't set attribute
+    >>> d.point
+    1
+    >>> d.point = 2
+    >>> d.point
+    2
+
+.. fix vim syntax issues: '
 
-You can set Models to be mutable and change Attribute values after creation
+You can set Models to be immutable
 
 .. code:: python
 
-    >>> @Model(mutable=True)
+    >>> @Model(mutable=False)
     ... @Attribute('point', type=int)
     ... class Data(object):
     ...     pass
@@ -234,8 +240,11 @@ You can set Models to be mutable and change Attribute values after creation
     >>> d.point
     1
     >>> d.point = 2
-    >>> d.point
-    2
+    Traceback (most recent call last):
+        ...
+    AttributeError: can't set attribute
+
+.. fix syntax: '
 
 This can also be done on a per Attribute basis
 

simple_model/__init__.py

@@ -7,7 +7,7 @@
 .. moduleauthor:: Aljosha Friemann a.friemann@automate.wtf
 """
 
-__version__ = '1.2.1'
+__version__ = '1.2.2'
 
 from simple_model.helpers import list_type, one_of
 from simple_model.v1 import Model, Attribute

simple_model/v2/__init__.py

@@ -1,12 +1,4 @@
 # -*- coding: utf-8 -*-
-"""
-.. module:: simple_model.v2
-   :platform: Unix
-   :synopsis: Simple decorator based models for easy data (de-)serialization and validation.
-
-.. moduleauthor:: Aljosha Friemann a.friemann@automate.wtf
-
-"""
 
 import copy
 
@@ -17,98 +9,96 @@
 class ModelError(RuntimeError):
     def __str__(self):
         def format_arg(arg):
-            return '- attribute: {}\n  value: "{}"\n  exception: {}'.format(*arg).strip()
+            return '- attribute: {}\n  value: "{}"\n  exception: {}'.format(
+                arg[0].name if arg[0] else None, arg[1], arg[2]
+            ).strip()
 
         return '{name}\n{errors}'.format(
             name=self.args[0],
             errors='\n'.join(
-                format_arg(arg) for arg in self.args[1]
+                format_arg(arg.args) for arg in self.args[1]
             )
         )
 
 
-class Model:
-    def __init__(self, mutable=False, hide_unset=False, drop_unknown=False, ignore_unknown=True):
+class Model(object):
+    def __init__(self, mutable=True, hide_unset=False, drop_unknown=False, ignore_unknown=True):
         self.mutable = mutable
         self.hide_unset = hide_unset
         self.drop_unknown = drop_unknown
         self.ignore_unknown = ignore_unknown
 
     def __call__(self, model):
-        custom_init = getattr(model, '__init__', None)
+        old_init = getattr(model, '__init__', None)
 
-        def __init__(cls, *args, **kwargs):
-            # make this instance memory independent from it's class.
-            cls.__attributes__ = copy.deepcopy(cls.__attributes__)
-
-            errors = []
+        def new_init(cls, *args, **kwargs):
+            exceptions = []
 
             for attribute in cls.__attributes__:
-                if attribute.is_set():
-                    # skip attributes that have already been set.
-                    continue
+                if hasattr(cls, attribute.name):
+                    if getattr(cls, attribute.name) is not Unset:
+                        continue
 
-                value = kwargs.pop(attribute.name, kwargs.pop(
-                                   attribute.alias,
-                                   Unset))
+                value = kwargs.pop(attribute.name,
+                        kwargs.pop(attribute.alias, Unset))  # noqa: E128
 
                 try:
-                    attribute.set(value=value)
+                    attribute.fset(cls, value)
                 except (AttributeError, ValueError) as e:
-                    errors.append((attribute, value, e))
-
-                mutable = attribute.mutable or (self.mutable and attribute.mutable is None)
+                    exception = AttributeError(attribute, value, e)
+                    exception.__cause__ = None
+                    exceptions.append(exception)
 
-                prop = property(
-                    fget=attribute.get,
-                    fset=attribute.set if mutable else None,
-                    fdel=attribute.unset if mutable else None,
-                    doc=attribute.help
-                )
-
-                setattr(model, attribute.name, prop)
+                if not self.mutable:
+                    setattr(model, attribute.name,
+                            property(fget=getattr(model, attribute.name).fget)
+                            )
 
             if kwargs:
                 if self.drop_unknown:
                     kwargs = {}
                 elif not self.ignore_unknown:
-                    errors.extend(
-                        (None, v, AttributeError('Unknown attribute "%s"' % k)) for k, v in kwargs.items()
+                    exceptions.extend(
+                        (AttributeError(None, v, 'Unknown attribute "%s"' % k) for k, v in kwargs.items())
                     )
 
-            if errors:
-                raise ModelError(cls.__class__.__name__, errors)
+            if exceptions:
+                raise ModelError(cls.__class__.__name__, exceptions)
 
-            if custom_init:
-                custom_init(cls, *args, **kwargs)
+            if old_init:
+                old_init(cls, *args, **kwargs)
 
-        if custom_init is not None:
-            __init__.__doc__ = custom_init.__doc__
+        if old_init:
+            new_init.__doc__ = old_init.__doc__
 
-        def __getitem__(cls, key):
-            for attribute in cls.__attributes__:
-                if attribute.name == key or attribute.alias == key:
+        def getitem(cls, key):
+            for a in cls.__attributes__:
+                if a.name == key or a.alias == key:
                     try:
-                        return dict(attribute.get())
+                        return dict(getattr(cls, a.name))
                     except (ValueError, TypeError):
-                        return attribute.get()
+                        return getattr(cls, a.name)
 
             raise KeyError(key)
 
-        model.__init__ = __init__
-        model.__getitem__ = __getitem__
+        model.__init__ = new_init
+        model.__getitem__ = getitem
+
         model.__str__ = lambda cls: str(dict(cls))
         model.__repr__ = lambda cls: str(dict(cls))
         model.__ne__ = lambda cls, o: not cls.__eq__(o)
-        model.__eq__ = lambda cls, o: (isinstance(o, cls.__class__) and dict(cls) == dict(o))
-        model.__contains__ = lambda cls, key: next((a for a in cls.__attributes__ if a.name == key and (a.is_set() or not self.hide_unset)), Unset) is not Unset
-        model.keys = lambda cls: sorted([ a.alias or a.name for a in cls.__attributes__ if (a.is_set() or not self.hide_unset)])
+        model.__eq__ = lambda cls, o: (issubclass(o.__class__, cls.__class__) and dict(cls) == dict(o))
+        model.__contains__ = lambda cls, key: getattr(cls, key) not in [None, Unset]
+        model.keys = lambda cls: sorted(
+            [a.alias or a.name for a in cls.__attributes__ if (
+                getattr(cls, a.name) not in [None, Unset] or not self.hide_unset)]
+        )
 
         return model
 
 
-class Attribute:
-    def __init__(self, name, type, optional=False, nullable=False, default=None, fdefault=None, mutable=None, alias=None, help=None):
+class Attribute(object):
+    def __init__(self, name, type, optional=False, nullable=False, mutable=True, default=None, fdefault=None, alias=None, help=None, value_by_reference=False):
         self.name = name
         self.type = type
         self.default = default
@@ -118,14 +108,10 @@ def __init__(self, name, type, optional=False, nullable=False, default=None, fde
         self.mutable = mutable
         self.alias = alias
         self.help = help
+        self.value_by_reference = value_by_reference
 
-        try:
-            if self.default is not None:
-                self.parse(self.default)
-            elif self.fdefault is not None:
-                self.parse(self.fdefault())
-        except Exception as e:
-            raise ValueError("Invalid default value(s) (%s/%s) for type %s" % (self.default, self.fdefault, self.type), e)
+    def __repr__(self):
+        return str(vars(self))
 
     def __call__(self, model):
         if not hasattr(model, '__attributes__'):
@@ -138,48 +124,52 @@ def __call__(self, model):
         finally:
             model.__attributes__.add(self)
 
+        setattr(model, self.value_name, Unset)
+
+        prop = property(
+            fget=self.fget,
+            fset=self.fset if self.mutable else None,
+            fdel=self.fdel if self.mutable else None,
+            doc=self.help
+        )
+
+        setattr(model, self.name, prop)
+
         return model
 
-    def __repr__(self):
-        return str(vars(self))
+    def fget(self, cls):
+        return getattr(cls, self.value_name)
 
-    def set(self, model=None, value=Unset):
+    def fset(self, cls, value):
         if value is Unset:
-            try:
-                value = self.get_default()
-            except AttributeError as e:
-                pass
+            if self.default is not None:
+                value = self.default
+            elif self.fdefault is not None:
+                value = self.fdefault()
 
-        try:
-            self.value = self.parse(value)
-        except NotImplementedError as e:
-            raise e
-        except Exception as e:
-            raise ValueError("Invalid value for Attribute: %s" % value, e)
+        setattr(cls, self.value_name, self.parse(value))
 
-    def get(self, model=None):
-        try:
-            return self.value
-        except AttributeError as e:
-            if not self.optional:
-                raise e
+    def fdel(self, cls):
+        setattr(cls, self.value_name, Unset)
 
-    def unset(self, model=None):
-        del self.value
+    @property
+    def value_name(self):
+        return '_%s' % self.name
 
     def parse(self, value):
         if value is Unset:
             if self.optional:
                 return value
             else:
-                raise ValueError("Non-optional attribute set with non-value.")
+                raise AttributeError(self, value, "Attribute is not optional")
         elif value is None:
             if self.nullable:
                 return None
             else:
                 value = self.get_default()
 
-        value = copy.deepcopy(value)
+        if not self.value_by_reference:
+            value = copy.deepcopy(value)
 
         if self.type is None:
             return value
@@ -189,18 +179,4 @@ def parse(self, value):
         except TypeError:
             return self.type(value)
 
-    def is_set(self):
-        try:
-            return self.value is not Unset
-        except AttributeError:
-            return False
-
-    def get_default(self):
-        if self.default is not None:
-            return self.default
-        elif self.fdefault is not None:
-            return self.fdefault()
-        else:
-            raise AttributeError("Attribute has no default")
-
 # vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4 fenc=utf-8