switch from characteristic to attrs

Author: radix

effect/_base.py

@@ -5,31 +5,24 @@
 
 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`.
     """
-    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,32 +2,33 @@
 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.
     """
-    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.
     """
+
+    dispatchers = attr.ib()
+
     def __init__(self, dispatchers):
         """
         :param collections.Iterable dispatchers: Dispatchers to search.

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,
@@ -41,11 +42,8 @@ class ParallelEffects(object):
     Performers of this intent must fail with a :obj:`FirstError` exception when
     any child effect fails, representing the first error.
     """
-    def __init__(self, effects):
-        """
-        :param effects: Effects which should be performed in parallel.
-        """
-        self.effects = effects
+
+    effects = attr.ib()
 
 
 def parallel(effects):
@@ -83,40 +81,35 @@ 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.
     """
-    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
+    result = attr.ib()
 
 
 @sync_performer
@@ -125,11 +118,10 @@ 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
+    exception = attr.ib()
 
 
 @sync_performer
@@ -138,7 +130,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.
@@ -158,11 +150,7 @@ class Func(object):
     this is useful for integrating wih "legacy" side-effecting code in a quick
     way.
     """
-    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):

effect/testing.py

@@ -12,7 +12,7 @@
 from functools import partial
 import sys
 
-from characteristic import attributes
+import attr
 
 from ._base import Effect, guard, _Box, NoPerformerFoundError
 from ._sync import NotSynchronousError, sync_performer
@@ -21,42 +21,43 @@
 import six
 
 
-@attributes(['intent'], apply_with_init=False)
+@attr.s
 class Stub(object):
     """
+    DEPRECATED in favor of using :obj:`SequenceDispatcher`.
+
+
     An intent which wraps another intent, to flag that the intent should
     be automatically resolved by :func:`resolve_stub`.
 
     :class:`Stub` is intentionally not performable by any default
     mechanism.
     """
-
-    def __init__(self, intent):
-        """
-        :param intent: The intent to perform with :func:`resolve_stub`.
-        """
-        self.intent = intent
+    intent = attr.ib()
 
 
 def ESConstant(x):
-    """Return Effect(Stub(Constant(x)))"""
+    """DEPRECATED. Return Effect(Stub(Constant(x)))"""
     return Effect(Stub(Constant(x)))
 
 
 def ESError(x):
-    """Return Effect(Stub(Error(x)))"""
+    """DEPRECATED. Return Effect(Stub(Error(x)))"""
     return Effect(Stub(Error(x)))
 
 
 def ESFunc(x):
-    """Return Effect(Stub(Func(x)))"""
+    """DEPRECATED. Return Effect(Stub(Func(x)))"""
     return Effect(Stub(Func(x)))
 
 
 def resolve_effect(effect, result, is_error=False):
     """
     Supply a result for an effect, allowing its callbacks to run.
 
+    Note that is a pretty low-level testing utility; it's much better to use a
+    higher-level tool like :obj:`SequenceDispatcher` in your tests.
+
     The return value of the last callback is returned, unless any callback
     returns another Effect, in which case an Effect representing that
     operation plus the remaining callbacks will be returned.
@@ -116,6 +117,8 @@ def fail_effect(effect, exception):
 
 def resolve_stub(dispatcher, effect):
     """
+    DEPRECATED in favor of obj:`SequenceDispatcher`.
+
     Automatically perform an effect, if its intent is a :obj:`Stub`.
 
     Note that resolve_stubs is preferred to this function, since it handles
@@ -147,6 +150,8 @@ def resolve_stub(dispatcher, effect):
 
 def resolve_stubs(dispatcher, effect):
     """
+    DEPRECATED in favor of obj:`SequenceDispatcher`.
+
     Successively performs effects with resolve_stub until a non-Effect value,
     or an Effect with a non-stub intent is returned, and return that value.
 
@@ -181,6 +186,10 @@ class EQDispatcher(object):
     This dispatcher looks up intents by equality and performs them by returning
     an associated constant value.
 
+    This is sometimes useful, but :obj:`SequenceDispatcher` should be
+    preferred, since it constrains the order of effects, which is usually
+    important.
+
     Users provide a mapping of intents to results, where the intents are
     matched against the intents being performed with a simple equality check
     (not a type check!).
@@ -219,6 +228,10 @@ class EQFDispatcher(object):
     This dispatcher looks up intents by equality and performs them by invoking
     an associated function.
 
+    This is sometimes useful, but :obj:`SequenceDispatcher` should be
+    preferred, since it constrains the order of effects, which is usually
+    important.
+
     Users provide a mapping of intents to functions, where the intents are
     matched against the intents being performed with a simple equality check
     (not a type check!). The functions in the mapping will be passed only the

setup.py

@@ -16,5 +16,5 @@
         'Programming Language :: Python :: 3',
         ],
     packages=['effect'],
-    install_requires=['six', 'characteristic>=14.0.0'],
+    install_requires=['six', 'attrs'],
     )