Merge pull request #57 from python-effect/switch-to-attrs

Switch to attrs

Author: radix

.travis.yml

@@ -7,9 +7,8 @@ python:
     - "3.4"
     - "pypy"
 install:
+    - pip install .
     - pip install -r dev-requirements.txt
-    - pip install six
-    - pip install 'characteristic>=14.0.0'
     - pip install sphinx
 script:
     - make lint

effect/_base.py

@@ -5,31 +5,26 @@
 
 from functools import partial
 
-from characteristic import attributes
+import attr
 
 import six
 
 from ._continuation import trampoline
 
 
-@attributes([
-    'intent', 'callbacks',
-], apply_with_init=False, apply_immutable=True)
+@attr.s
 class Effect(object):
     """
     Take an object that describes a desired effect (called an "Intent"), and
     allow binding callbacks to be called with the result of the effect.
 
     Effects can be performed with :func:`perform`.
+
+    :param intent: The intent to be performed.
     """
-    def __init__(self, intent, callbacks=None):
-        """
-        :param intent: An object that describes an effect to be performed.
-        """
-        self.intent = intent
-        if callbacks is None:
-            callbacks = []
-        self.callbacks = callbacks
+
+    intent = attr.ib()
+    callbacks = attr.ib(default=attr.Factory(list))
 
     def on(self, success=None, error=None):
         """

effect/_dispatcher.py

@@ -2,37 +2,35 @@
 Dispatcher!
 """
 
+import attr
+
 from six.moves import filter
-from characteristic import attributes
 
 
-@attributes(['mapping'], apply_with_init=False)
+@attr.s
 class TypeDispatcher(object):
     """
     An Effect dispatcher which looks up the performer to use by type.
+
+    :param mapping: mapping of intent type to performer
     """
-    def __init__(self, mapping):
-        """
-        :param collections.Mapping mapping: mapping of intent type to performer
-        """
-        self.mapping = mapping
+    mapping = attr.ib()
 
     def __call__(self, intent):
         return self.mapping.get(type(intent))
 
 
-@attributes(['dispatchers'], apply_with_init=False)
+@attr.s
 class ComposedDispatcher(object):
     """
     A dispatcher which composes other dispatchers.
 
     The dispatchers given will be searched in order until a performer is found.
+
+    :param dispatchers: Dispatchers to search.
     """
-    def __init__(self, dispatchers):
-        """
-        :param collections.Iterable dispatchers: Dispatchers to search.
-        """
-        self.dispatchers = dispatchers
+
+    dispatchers = attr.ib()
 
     def __call__(self, intent):
         return next(filter(None, (d(intent) for d in self.dispatchers)), None)

effect/_intents.py

@@ -16,14 +16,15 @@
 
 
 from __future__ import print_function, absolute_import
-from characteristic import attributes
+
+import attr
 
 from ._base import Effect
 from ._sync import sync_performer
 from ._dispatcher import TypeDispatcher
 
 
-@attributes(['effects'], apply_with_init=False, apply_immutable=True)
+@attr.s
 class ParallelEffects(object):
     """
     An effect intent that asks for a number of effects to be run in parallel,
@@ -40,12 +41,11 @@ class ParallelEffects(object):
 
     Performers of this intent must fail with a :obj:`FirstError` exception when
     any child effect fails, representing the first error.
+
+    :param effects: Effects to be performed in parallel.
     """
-    def __init__(self, effects):
-        """
-        :param effects: Effects which should be performed in parallel.
-        """
-        self.effects = effects
+
+    effects = attr.ib()
 
 
 def parallel(effects):
@@ -83,40 +83,41 @@ def parallel_all_errors(effects):
     return Effect(ParallelEffects(list(effects)))
 
 
-@attributes(['exc_info', 'index'])
+@attr.s
 class FirstError(Exception):
     """
     One of the effects in a :obj:`ParallelEffects` resulted in an error. This
     represents the first such error that occurred.
     """
+    exc_info = attr.ib()
+    index = attr.ib()
+
     def __str__(self):
         return '(index=%s) %s: %s' % (
             self.index, self.exc_info[0].__name__, self.exc_info[1])
 
 
-@attributes(['delay'], apply_with_init=False, apply_immutable=True)
+@attr.s
 class Delay(object):
     """
     An intent which represents a delay in time.
 
     When performed, the specified delay will pass and then the effect will
     result in None.
+
+    :param float delay: The number of seconds to delay.
     """
-    def __init__(self, delay):
-        """
-        :param float delay: The number of seconds to delay.
-        """
-        self.delay = delay
+    delay = attr.ib()
 
 
-@attributes(['result'], apply_with_init=False, apply_immutable=True)
+@attr.s
 class Constant(object):
-    """An intent that returns a pre-specified result when performed."""
-    def __init__(self, result):
-        """
-        :param result: The object which the Effect should result in.
-        """
-        self.result = result
+    """
+    An intent that returns a pre-specified result when performed.
+
+    :param result: The object which the Effect will result in.
+    """
+    result = attr.ib()
 
 
 @sync_performer
@@ -125,11 +126,14 @@ def perform_constant(dispatcher, intent):
     return intent.result
 
 
-@attributes(['exception'], apply_with_init=False, apply_immutable=True)
+@attr.s
 class Error(object):
-    """An intent that raises a pre-specified exception when performed."""
-    def __init__(self, exception):
-        self.exception = exception
+    """
+    An intent that raises a pre-specified exception when performed.
+
+    :param BaseException exception: Exception instance to raise.
+    """
+    exception = attr.ib()
 
 
 @sync_performer
@@ -138,7 +142,7 @@ def perform_error(dispatcher, intent):
     raise intent.exception
 
 
-@attributes(['func'], apply_with_init=False, apply_immutable=True)
+@attr.s
 class Func(object):
     """
     An intent that returns the result of the specified function.
@@ -157,12 +161,10 @@ class Func(object):
     intents as inert objects with public attributes of simple data. However,
     this is useful for integrating wih "legacy" side-effecting code in a quick
     way.
+
+    :param func: The function to call when this intent is performed.
     """
-    def __init__(self, func):
-        """
-        :param func: The function to call when this intent is performed.
-        """
-        self.func = func
+    func = attr.ib()
 
 
 @sync_performer

effect/_test_utils.py

@@ -3,13 +3,16 @@
 import sys
 import traceback
 
-from characteristic import attributes
+import attr
 
 from testtools.matchers import Equals
 
 
-@attributes(['expected_tb', 'got_tb'])
+@attr.s
 class ReraisedTracebackMismatch(object):
+    expected_tb = attr.ib()
+    got_tb = attr.ib()
+
     def describe(self):
         return ("The reference traceback:\n"
                 + ''.join(self.expected_tb)
@@ -18,11 +21,10 @@ def describe(self):
                 + "\nbut it doesn't.")
 
 
-@attributes(['expected'], apply_with_init=False)
+@attr.s
 class MatchesReraisedExcInfo(object):
 
-    def __init__(self, expected):
-        self.expected = expected
+    expected = attr.ib()
 
     def match(self, actual):
         valcheck = Equals(self.expected[1]).match(actual[1])

effect/ref.py

@@ -1,4 +1,4 @@
-from characteristic import attributes
+import attr
 
 from ._base import Effect
 from ._dispatcher import TypeDispatcher
@@ -42,12 +42,14 @@ def __repr__(self):
         return "<Reference({})>".format(self._value)
 
 
-@attributes(['ref'])
+@attr.s
 class ReadReference(object):
     """Intent that gets a Reference's current value."""
 
+    ref = attr.ib()
 
-@attributes(['ref', 'transformer'])
+
+@attr.s
 class ModifyReference(object):
     """
     Intent that modifies a Reference value in-place with a transformer func.
@@ -56,6 +58,9 @@ class ModifyReference(object):
     modifying the same reference at the same time.
     """
 
+    ref = attr.ib()
+    transformer = attr.ib()
+
 
 @sync_performer
 def perform_read_reference(dispatcher, intent):

effect/test_parallel_performers.py

@@ -1,6 +1,6 @@
 from functools import partial
 
-from characteristic import attributes
+import attr
 
 import six
 
@@ -12,9 +12,9 @@
 from ._test_utils import MatchesReraisedExcInfo, get_exc_info
 
 
-@attributes(['message'])
+@attr.s
 class EquitableException(Exception):
-    pass
+    message = attr.ib()
 
 
 class ParallelPerformerTestsMixin(object):