Commits

Lynn Rees  committed b1fb1a8

- consolidate

  • Participants
  • Parent commits fe5c2f2
  • Branches next

Comments (0)

Files changed (52)

File thingq/active/core.py

 '''thingq active queues'''
 
 from thingq.mixins import SLOTS
-from thingq.mapping import MappingMixin as MapMixin
-from thingq.ordering import OrderingMixin as OrderMixin
-from thingq.reducing import ReducingMixin as ReduceMixin
-from thingq.filtering import FilteringMixin as FilterMixin
+from thingq.mapping import RepeatMixin, MapMixin
+from thingq.ordering import RandomMixin, OrderMixin
+from thingq.reducing import MathMixin, TruthMixin, ReduceMixin
+from thingq.active.mixins import AutoResultMixin, ManResultMixin
+from thingq.filtering import FilterMixin, CollectMixin, SetMixin, SliceMixin
 
-from thingq.active.mixins import AutoResultMixin, ManResultMixin
 
-
-class autoq(AutoResultMixin, FilterMixin, MapMixin, ReduceMixin, OrderMixin):
+class autoq(
+    AutoResultMixin, FilterMixin, MapMixin, ReduceMixin, OrderMixin,
+    CollectMixin, SetMixin, SliceMixin, TruthMixin, MathMixin, RepeatMixin,
+    RandomMixin,
+):
 
     '''auto-balancing manipulation queue'''
 
     __slots__ = SLOTS
 
 
-class manq(ManResultMixin, FilterMixin, MapMixin, ReduceMixin, OrderMixin):
+class manq(
+    ManResultMixin, FilterMixin, MapMixin, ReduceMixin, OrderMixin,
+    CollectMixin, SetMixin, SliceMixin, TruthMixin, MathMixin, RepeatMixin,
+    RandomMixin,
+):
 
     '''manually balanced manipulation queue'''
 
     __slots__ = SLOTS
+
+
+class collectq(AutoResultMixin, CollectMixin):
+
+    '''auto-balanced collecting queue'''
+
+    __slots__ = SLOTS
+
+
+class mcollectq(ManResultMixin, CollectMixin):
+
+    '''manually balanced collecting queue'''
+
+    __slots__ = SLOTS
+
+
+class setq(AutoResultMixin, SetMixin):
+
+    '''auto-balanced set queue'''
+
+    __slots__ = SLOTS
+
+
+class msetq(ManResultMixin, SetMixin):
+
+    '''manually balanced set queue'''
+
+    __slots__ = SLOTS
+
+
+class sliceq(AutoResultMixin, SliceMixin):
+
+    '''auto-balanced slice queue'''
+
+    __slots__ = SLOTS
+
+
+class msliceq(ManResultMixin, SliceMixin):
+
+    '''manually balanced slice queue'''
+
+    __slots__ = SLOTS
+
+
+class filterq(AutoResultMixin, FilterMixin):
+
+    '''auto-balanced filter queue'''
+
+    __slots__ = SLOTS
+
+
+class mfilterq(ManResultMixin, FilterMixin):
+
+    '''manually balanced filtering queue'''
+
+    __slots__ = SLOTS
+
+
+class repeatq(AutoResultMixin, RepeatMixin):
+
+    '''auto-balanced repeat queue'''
+
+    __slots__ = SLOTS
+
+
+class mrepeatq(ManResultMixin, RepeatMixin):
+
+    '''manually balanced repeat queue'''
+
+    __slots__ = SLOTS
+
+
+class mapq(AutoResultMixin, MapMixin):
+
+    '''auto-balanced mapping queue'''
+
+    __slots__ = SLOTS
+
+
+class mmapq(ManResultMixin, MapMixin):
+
+    '''manually balanced mapping queue'''
+
+    __slots__ = SLOTS
+
+
+class randomq(AutoResultMixin, RandomMixin):
+
+    '''auto-balanced randomizing queue'''
+
+    __slots__ = SLOTS
+
+
+class mrandomq(ManResultMixin, RandomMixin):
+
+    '''manually balanced randomizing queue'''
+
+    __slots__ = SLOTS
+
+
+class orderq(AutoResultMixin, OrderMixin):
+
+    '''auto-balanced ordering queue'''
+
+    __slots__ = SLOTS
+
+
+class morderq(ManResultMixin, OrderMixin):
+
+    '''manually balanced order queue'''
+
+    __slots__ = SLOTS
+
+
+class mathq(AutoResultMixin, MathMixin):
+
+    '''auto-balancing math queue'''
+
+    __slots__ = SLOTS
+
+
+class mmathq(ManResultMixin, MathMixin):
+
+    '''manually balanced math queue'''
+
+    __slots__ = SLOTS
+
+
+class truthq(AutoResultMixin, TruthMixin):
+
+    '''auto-balancing truth queue'''
+
+    __slots__ = SLOTS
+
+
+class mtruthq(ManResultMixin, TruthMixin):
+
+    '''manually balanced truth queue'''
+
+    __slots__ = SLOTS
+
+
+class reduceq(AutoResultMixin, ReduceMixin):
+
+    '''auto-balancing reduce queue'''
+
+    __slots__ = SLOTS
+
+
+class mreduceq(ManResultMixin, ReduceMixin):
+
+    '''manually balanced reduce queue'''
+
+    __slots__ = SLOTS

File thingq/active/filtering.py

-# -*- coding: utf-8 -*-
-'''thingq active filtering queues'''
-
-from thingq.mixins import SLOTS
-from thingq.filtering import (
-    FilteringMixin, CollectMixin, SetMixin, SliceMixin)
-
-from thingq.active.mixins import AutoResultMixin, ManResultMixin
-
-
-class collectq(AutoResultMixin, CollectMixin):
-
-    '''auto-balanced collecting queue'''
-
-    __slots__ = SLOTS
-
-
-class mcollectq(ManResultMixin, CollectMixin):
-
-    '''manually balanced collecting queue'''
-
-    __slots__ = SLOTS
-
-
-class setq(AutoResultMixin, SetMixin):
-
-    '''auto-balanced set queue'''
-
-    __slots__ = SLOTS
-
-
-class msetq(ManResultMixin, SetMixin):
-
-    '''manually balanced set queue'''
-
-    __slots__ = SLOTS
-
-
-class sliceq(AutoResultMixin, SliceMixin):
-
-    '''auto-balanced slice queue'''
-
-    __slots__ = SLOTS
-
-
-class msliceq(ManResultMixin, SliceMixin):
-
-    '''manually balanced slice queue'''
-
-    __slots__ = SLOTS
-
-
-class filterq(AutoResultMixin, FilteringMixin):
-
-    '''auto-balanced filter queue'''
-
-    __slots__ = SLOTS
-
-
-class mfilterq(ManResultMixin, FilteringMixin):
-
-    '''manually balanced filtering queue'''
-
-    __slots__ = SLOTS

File thingq/active/mapping.py

-# -*- coding: utf-8 -*-
-'''thingq active mapping queues'''
-
-from thingq.mixins import SLOTS
-from thingq.mapping import DelayMixin, RepeatMixin, MappingMixin
-
-from thingq.active.mixins import AutoResultMixin, ManResultMixin
-
-
-class delayq(AutoResultMixin, DelayMixin):
-
-    '''auto-balanced delayed map queue'''
-
-    __slots__ = SLOTS
-
-
-class mdelayq(ManResultMixin, DelayMixin):
-
-    '''manually balanced delayed map queue'''
-
-    __slots__ = SLOTS
-
-
-class repeatq(AutoResultMixin, RepeatMixin):
-
-    '''auto-balanced repeat queue'''
-
-    __slots__ = SLOTS
-
-
-class mrepeatq(ManResultMixin, RepeatMixin):
-
-    '''manually balanced repeat queue'''
-
-    __slots__ = SLOTS
-
-
-class mapq(AutoResultMixin, MappingMixin):
-
-    '''auto-balanced mapping queue'''
-
-    __slots__ = SLOTS
-
-
-class mmapq(ManResultMixin, MappingMixin):
-
-    '''manually balanced mapping queue'''
-
-    __slots__ = SLOTS

File thingq/active/mixins.py

     ## iterate things #########################################################
     ###########################################################################
 
-    def __iter__(self):
-        '''yield outgoing things, clearing outgoing things as it iterates'''
-        return self._iterexcept(self._OUTQ)
-
     @property
     def _iterable(self):
         '''iterable'''
 class EndMixin(ResultsMixin):
 
     '''result things mixin'''
+    
+    def __iter__(self):
+        '''yield outgoing things, clearing outgoing things as it iterates'''
+        return self._iterexcept(self._OUTQ)
+    
+    results = __iter__
 
     def end(self):
         '''return outgoing things then clear wrap everything'''

File thingq/active/ordering.py

-# -*- coding: utf-8 -*-
-'''thingq active ordering queues'''
-
-from thingq.mixins import SLOTS
-from thingq.ordering import RandomMixin, OrderingMixin
-
-from thingq.active.mixins import AutoResultMixin, ManResultMixin
-
-
-class randomq(AutoResultMixin, RandomMixin):
-
-    '''auto-balanced randomizing queue'''
-
-    __slots__ = SLOTS
-
-
-class mrandomq(ManResultMixin, RandomMixin):
-
-    '''manually balanced randomizing queue'''
-
-    __slots__ = SLOTS
-
-
-class orderq(AutoResultMixin, OrderingMixin):
-
-    '''auto-balanced ordering queue'''
-
-    __slots__ = SLOTS
-
-
-class morderq(ManResultMixin, OrderingMixin):
-
-    '''manually balanced order queue'''
-
-    __slots__ = SLOTS

File thingq/active/reducing.py

-# -*- coding: utf-8 -*-
-'''thingq active reducing queues'''
-
-from thingq.mixins import SLOTS
-from thingq.reducing import MathMixin, TruthMixin, ReducingMixin
-
-from thingq.active.mixins import AutoResultMixin, ManResultMixin
-
-
-class mathq(AutoResultMixin, MathMixin):
-
-    '''auto-balancing math queue'''
-
-    __slots__ = SLOTS
-
-
-class mmathq(ManResultMixin, MathMixin):
-
-    '''manually balanced math queue'''
-
-    __slots__ = SLOTS
-
-
-class truthq(AutoResultMixin, TruthMixin):
-
-    '''auto-balancing truth queue'''
-
-    __slots__ = SLOTS
-
-
-class mtruthq(ManResultMixin, TruthMixin):
-
-    '''manually balanced truth queue'''
-
-    __slots__ = SLOTS
-
-
-class reduceq(AutoResultMixin, ReducingMixin):
-
-    '''auto-balancing reduce queue'''
-
-    __slots__ = SLOTS
-
-
-class mreduceq(ManResultMixin, ReducingMixin):
-
-    '''manually balanced reduce queue'''
-
-    __slots__ = SLOTS

File thingq/filtering.py

             return self._xtend(
                 filterfalse(lambda y: y in things, self._iterable)
             )
-
-
-class FilteringMixin(CollectMixin, SetMixin, SliceMixin, FilterMixin):
-
-    '''filtering mixin'''

File thingq/lazy/core.py

 '''thingq lazy queues'''
 
 from thingq.mixins import SLOTS
-from thingq.mapping import MappingMixin as MapMixin
-from thingq.ordering import OrderingMixin as OrderMixin
-from thingq.reducing import ReducingMixin as ReduceMixin
-from thingq.filtering import FilteringMixin as FilterMixin
+from thingq.mapping import RepeatMixin, MapMixin
+from thingq.ordering import RandomMixin, OrderMixin
+from thingq.lazy.mixins import AutoResultMixin, ManResultMixin
+from thingq.reducing import MathMixin, TruthMixin, ReduceMixin
+from thingq.filtering import FilterMixin, CollectMixin, SetMixin, SliceMixin
 
-from thingq.lazy.mixins import AutoResultMixin, ManResultMixin
 
-
-class autoq(AutoResultMixin, FilterMixin, MapMixin, ReduceMixin, OrderMixin):
+class autoq(
+    AutoResultMixin, FilterMixin, MapMixin, ReduceMixin, OrderMixin,
+    CollectMixin, SetMixin, SliceMixin, TruthMixin, MathMixin, RepeatMixin,
+    RandomMixin,
+):
 
     '''auto-balancing manipulation queue'''
 
     __slots__ = SLOTS
 
 
-class manq(ManResultMixin, FilterMixin, MapMixin, ReduceMixin, OrderMixin):
+class manq(
+    ManResultMixin, FilterMixin, MapMixin, ReduceMixin, OrderMixin,
+    CollectMixin, SetMixin, SliceMixin, TruthMixin, MathMixin, RepeatMixin,
+    RandomMixin,
+):
 
     '''manually balanced manipulation queue'''
 
     __slots__ = SLOTS
 
 
-lazyq = autoq
+class collectq(AutoResultMixin, CollectMixin):
+
+    '''auto-balanced collecting queue'''
+
+    __slots__ = SLOTS
+
+
+class mcollectq(ManResultMixin, CollectMixin):
+
+    '''manually balanced collecting queue'''
+
+    __slots__ = SLOTS
+
+
+class setq(AutoResultMixin, SetMixin):
+
+    '''auto-balanced set queue'''
+
+    __slots__ = SLOTS
+
+
+class msetq(ManResultMixin, SetMixin):
+
+    '''manually balanced set queue'''
+
+    __slots__ = SLOTS
+
+
+class sliceq(AutoResultMixin, SliceMixin):
+
+    '''auto-balanced slice queue'''
+
+    __slots__ = SLOTS
+
+
+class msliceq(ManResultMixin, SliceMixin):
+
+    '''manually balanced slice queue'''
+
+    __slots__ = SLOTS
+
+
+class filterq(AutoResultMixin, FilterMixin):
+
+    '''auto-balanced filter queue'''
+
+    __slots__ = SLOTS
+
+
+class mfilterq(ManResultMixin, FilterMixin):
+
+    '''manually balanced filtering queue'''
+
+    __slots__ = SLOTS
+
+
+class repeatq(AutoResultMixin, RepeatMixin):
+
+    '''auto-balanced repeat queue'''
+
+    __slots__ = SLOTS
+
+
+class mrepeatq(ManResultMixin, RepeatMixin):
+
+    '''manually balanced repeat queue'''
+
+    __slots__ = SLOTS
+
+
+class mapq(AutoResultMixin, MapMixin):
+
+    '''auto-balanced map queue'''
+
+    __slots__ = SLOTS
+
+
+class mmapq(ManResultMixin, MapMixin):
+
+    '''manually balanced map queue'''
+
+    __slots__ = SLOTS
+
+
+class randomq(AutoResultMixin, RandomMixin):
+
+    '''auto-balanced random queue'''
+
+    __slots__ = SLOTS
+
+
+class mrandomq(ManResultMixin, RandomMixin):
+
+    '''manually balanced random queue'''
+
+    __slots__ = SLOTS
+
+
+class orderq(AutoResultMixin, OrderMixin):
+
+    '''auto-balanced order queue'''
+
+    __slots__ = SLOTS
+
+
+class morderq(ManResultMixin, OrderMixin):
+
+    '''manually balanced order queue'''
+
+    __slots__ = SLOTS
+
+
+class mathq(AutoResultMixin, MathMixin):
+
+    '''auto-balancing math queue'''
+
+    __slots__ = SLOTS
+
+
+class mmathq(ManResultMixin, MathMixin):
+
+    '''manually balanced math queue'''
+
+    __slots__ = SLOTS
+
+
+class truthq(AutoResultMixin, TruthMixin):
+
+    '''auto-balancing truth queue'''
+
+    __slots__ = SLOTS
+
+
+class mtruthq(ManResultMixin, TruthMixin):
+
+    '''manually balanced truth queue'''
+
+    __slots__ = SLOTS
+
+
+class reduceq(AutoResultMixin, ReduceMixin):
+
+    '''auto-balancing reduce queue'''
+
+    __slots__ = SLOTS
+
+
+class mreduceq(ManResultMixin, ReduceMixin):
+
+    '''manually balanced reduce queue'''
+
+    __slots__ = SLOTS

File thingq/lazy/filtering.py

-# -*- coding: utf-8 -*-
-'''thingq lazy filtering queues'''
-
-from thingq.mixins import SLOTS
-from thingq.filtering import (
-    FilteringMixin, CollectMixin, SetMixin, SliceMixin)
-
-from thingq.lazy.mixins import AutoResultMixin, ManResultMixin
-
-
-class collectq(AutoResultMixin, CollectMixin):
-
-    '''auto-balanced collecting queue'''
-
-    __slots__ = SLOTS
-
-
-class mcollectq(ManResultMixin, CollectMixin):
-
-    '''manually balanced collecting queue'''
-
-    __slots__ = SLOTS
-
-
-class setq(AutoResultMixin, SetMixin):
-
-    '''auto-balanced set queue'''
-
-    __slots__ = SLOTS
-
-
-class msetq(ManResultMixin, SetMixin):
-
-    '''manually balanced set queue'''
-
-    __slots__ = SLOTS
-
-
-class sliceq(AutoResultMixin, SliceMixin):
-
-    '''auto-balanced slice queue'''
-
-    __slots__ = SLOTS
-
-
-class msliceq(ManResultMixin, SliceMixin):
-
-    '''manually balanced slice queue'''
-
-    __slots__ = SLOTS
-
-
-class filterq(AutoResultMixin, FilteringMixin):
-
-    '''auto-balanced filter queue'''
-
-    __slots__ = SLOTS
-
-
-class mfilterq(ManResultMixin, FilteringMixin):
-
-    '''manually balanced filtering queue'''
-
-    __slots__ = SLOTS

File thingq/lazy/mapping.py

-# -*- coding: utf-8 -*-
-'''thingq lazy mapping queues'''
-
-from thingq.mixins import SLOTS
-from thingq.mapping import DelayMixin, RepeatMixin, MappingMixin
-
-from thingq.lazy.mixins import AutoResultMixin, ManResultMixin
-
-
-class delayq(AutoResultMixin, DelayMixin):
-
-    '''auto-balanced delayed map queue'''
-
-    __slots__ = SLOTS
-
-
-class mdelayq(ManResultMixin, DelayMixin):
-
-    '''manually balanced delayed map queue'''
-
-    __slots__ = SLOTS
-
-
-class repeatq(AutoResultMixin, RepeatMixin):
-
-    '''auto-balanced repeat queue'''
-
-    __slots__ = SLOTS
-
-
-class mrepeatq(ManResultMixin, RepeatMixin):
-
-    '''manually balanced repeat queue'''
-
-    __slots__ = SLOTS
-
-
-class mapq(AutoResultMixin, MappingMixin):
-
-    '''auto-balanced map queue'''
-
-    __slots__ = SLOTS
-
-
-class mmapq(ManResultMixin, MappingMixin):
-
-    '''manually balanced map queue'''
-
-    __slots__ = SLOTS

File thingq/lazy/mixins.py

     ###########################################################################
 
     def _savepoint(self):
-        '''take savepoint of incoming'''
+        '''make savepoint of incoming things'''
         savepoint, self.incoming = tee(getattr(self, self._INQ))
         self._savepoints.append(savepoint)
         return self
     ## iterate things #########################################################
     ###########################################################################
 
-    def __iter__(self):
-        '''yield outgoing things, clearing outgoing things as it iterates'''
-        return getattr(self, self._OUTQ)
-
     @property
     def _iterable(self):
         '''iterable'''
 class EndMixin(ResultsMixin):
 
     '''result things mixin'''
+    
+    def __iter__(self):
+        '''yield outgoing things, clearing outgoing things as it iterates'''
+        return getattr(self, self._OUTQ)
+    
+    results = __iter__
 
     def end(self):
         '''return outgoing things then clear out everything'''

File thingq/lazy/ordering.py

-# -*- coding: utf-8 -*-
-'''thingq lazy ordering queues'''
-
-from thingq.mixins import SLOTS
-from thingq.ordering import RandomMixin, OrderingMixin
-
-from thingq.lazy.mixins import AutoResultMixin, ManResultMixin
-
-
-class randomq(AutoResultMixin, RandomMixin):
-
-    '''auto-balanced random queue'''
-
-    __slots__ = SLOTS
-
-
-class mrandomq(ManResultMixin, RandomMixin):
-
-    '''manually balanced random queue'''
-
-    __slots__ = SLOTS
-
-
-class orderq(AutoResultMixin, OrderingMixin):
-
-    '''auto-balanced order queue'''
-
-    __slots__ = SLOTS
-
-
-class morderq(ManResultMixin, OrderingMixin):
-
-    '''manually balanced order queue'''
-
-    __slots__ = SLOTS

File thingq/lazy/reducing.py

-# -*- coding: utf-8 -*-
-'''thingq lazy reducing queues'''
-
-from thingq.mixins import SLOTS
-from thingq.reducing import MathMixin, TruthMixin, ReducingMixin
-
-from thingq.lazy.mixins import AutoResultMixin, ManResultMixin
-
-
-class mathq(AutoResultMixin, MathMixin):
-
-    '''auto-balancing math queue'''
-
-    __slots__ = SLOTS
-
-
-class mmathq(ManResultMixin, MathMixin):
-
-    '''manually balanced math queue'''
-
-    __slots__ = SLOTS
-
-
-class truthq(AutoResultMixin, TruthMixin):
-
-    '''auto-balancing truth queue'''
-
-    __slots__ = SLOTS
-
-
-class mtruthq(ManResultMixin, TruthMixin):
-
-    '''manually balanced truth queue'''
-
-    __slots__ = SLOTS
-
-
-class reduceq(AutoResultMixin, ReducingMixin):
-
-    '''auto-balancing reduce queue'''
-
-    __slots__ = SLOTS
-
-
-class mreduceq(ManResultMixin, ReducingMixin):
-
-    '''manually balanced reduce queue'''
-
-    __slots__ = SLOTS

File thingq/mapping.py

 from thingq.support import imap, ichain, items, xrange
 
 
-class DelayMixin(local):
-
-    '''delayed map mixin'''
-
-    def delay_each(self, wait):
-        '''
-        invoke call with passed arguments, keywords in incoming things after
-        delay `wait`
-
-        @param wait: time in seconds
-        '''
-        def delay_each(x, y, wait=0, caller=None):
-            sleep(wait)
-            return caller(*x, **y)
-        with self._context():
-            de, call = delay_each, self._call
-            return self._xtend(starmap(
-                lambda x, y: de(x, y, wait, call), self._iterable,
-            ))
-
-    def delay_invoke(self, name, wait):
-        '''
-        invoke method `name` on each incoming thing with passed arguments,
-        keywords after delay `wait` but return incoming thing instead if method
-        returns `None`
-
-        @param name: name of method
-        @param wait: time in seconds
-        '''
-        def delay_invoke(x, wait=0, caller=None):
-            sleep(wait)
-            results = caller(x)
-            return x if results is None else results
-        with self._context():
-            di, mc = delay_invoke, methodcaller
-            args, kw = self._args, self._kw
-            return self._xtend(imap(
-                lambda x: di(x, wait, mc(name, *args, **kw)), self._iterable,
-            ))
-
-    def delay_map(self, wait):
-        '''
-        invoke call on each incoming thing after delay `wait`
-
-        @param wait: time in seconds
-        '''
-        def delay_map(x, wait=None, caller=None):
-            sleep(wait)
-            return caller(x)
-        with self._context():
-            dm, call = delay_map, self._call
-            return self._xtend(imap(
-                lambda x: dm(x, wait, call), self._iterable,
-            ))
-
-
 class RepeatMixin(local):
 
     '''repetition mixin'''
 
     '''mapping mixin'''
 
-    def each(self):
-        '''invoke call with passed arguments, keywords in incoming things'''
+    def each(self, wait=0):
+        '''
+        invoke call with passed arguments, keywords in incoming things
+
+        @param wait: time in seconds (default: 0)
+        '''
+        call = self._call
+        if wait:
+            def delay_each(x, y, wait=0, caller=None):
+                sleep(wait)
+                return caller(*x, **y)
+            de = delay_each
+            call_ = lambda x, y: de(x, y, wait, call)
+        else:
+            
+            call_ = lambda x, y: call(*x, **y)
         with self._context():
-            return self._xtend(starmap(
-                lambda x, y: self._call(*x, **y), self._iterable,
-            ))
+            return self._xtend(starmap(call_, self._iterable))
 
-    def invoke(self, name):
+    def invoke(self, name, wait=0):
         '''
         invoke method `name` on each incoming thing with passed arguments,
         keywords but return incoming thing instead if method returns `None`
 
         @param name: name of method
+        @param wait: time in seconds (default: 0)
         '''
-        def invoke(thing, caller=None):
+        caller = methodcaller(name, *self._args, **self._kw)
+        def invoke(thing):
             results = caller(thing)
             return thing if results is None else results
+        if wait:
+            def invoke(x, wait=0):
+                sleep(wait)
+                return invoke(x)
         with self._context():
-            return self._xtend(imap(
-                lambda x: invoke(
-                    x, caller=methodcaller(name, *self._args, **self._kw)
-                ),
-                self._iterable
-            ))
+            return self._xtend(imap(invoke, self._iterable))
 
     def items(self):
         '''invoke call on each mapping to get key, value pairs'''
                 self._call, ichain(imap(items, self._iterable))
             ))
 
-    def map(self):
-        '''invoke call on each incoming thing'''
+    def map(self, wait=0):
+        '''
+        invoke call on each incoming thing
+        
+        @param wait: time in seconds (default: 0)
+        '''
+        call_ = self._call
+        if wait:
+            def delay_map(x, wait=None, caller=None):
+                sleep(wait)
+                return caller(x)
+            call_ = lambda x: delay_map(x, wait, call_)
         with self._context():
-            return self._xtend(imap(self._call, self._iterable))
+            return self._xtend(imap(call_, self._iterable))
 
     def starmap(self):
         '''invoke call on each sequence of incoming things'''
         with self._context():
             return self._xtend(starmap(self._call, self._iterable))
-
-
-class MappingMixin(DelayMixin, RepeatMixin, MapMixin):
-
-    '''mapping mixin'''

File thingq/mixins.py

         # clear outgoing things before extending/appending to them?
         self._clearout = True
         #######################################################################
-        ## snapshotting defaults ##############################################
+        ## savepoint defaults #################################################
         #######################################################################
-        # number of savepoints to keep (default: 5)
+        # number of savepoints to retain (default: 5)
         maxlen = kw.pop('savepoints', 5)
         # create stack for savepoint things
         self._savepoints = deque(maxlen=maxlen) if maxlen is not None else None
     def rw(self):
         '''switch to read/write mode'''
         self.current_mode = self._RW
+        # clear utility queue
         return self._clearu().unswap()
 
     ###########################################################################
         self._CONFIG = kw if kw.get('hard', False) else {}
         # set context
         self._context = kw.get('context', getattr(self, self._DEFAULT_CONTEXT))
-        # clear wrap outgoing things before extending them?
+        # clear outgoing things before extending them?
         self._clearout = kw.get('clearout', True)
         # 1. incoming things
         self._INQ = kw.get(self._INCFG, self._INVAR)
         return self
 
     def reswap(self):
-        '''swap for preferred context'''
+        '''swap for current default context'''
         return self.swap(savepoint=False, **self._CONFIG)
 
     def unswap(self):
-        '''swap for current default context'''
+        '''swap for preferred context'''
         return self.swap(savepoint=False)
 
     @contextmanager
         @param everything: undo everything and return things to original state
         '''
         if everything:
+            # clear everything plus savepoints
             self.clear()._clearsp()
+            # restore original incoming things
             self.incoming = self._start
+            # take new snapshot for incoming things
             self._original()
             return self
         self.clear()
+        # by default use most recent savepoint
         if not index:
             self.incoming = self._savepoints.pop()
+        # if specified, use savepoint at specific index
         else:
             self.incoming = deque(reversed(self._savepoints))[index]
         return self._savepoint()
     '''result of things mixin'''
 
     ###########################################################################
-    ## outgoing things export #################################################
+    ## export outgoing things #################################################
     ###########################################################################
 
     def peek(self):
         self.rw()
         return results
 
-    def results(self):
-        '''yield outgoing things, clearing outgoing things as it iterates'''
-        return self.__iter__()
-
     ###########################################################################
     ## wrap outgoing things ###################################################
     ###########################################################################

File thingq/ordering.py

         call_ = self._call
         with self._context():
             return self._xtend(sorted(self._iterable, key=call_))
-
-
-class OrderingMixin(OrderMixin, RandomMixin):
-
-    '''ordering mixin'''

File thingq/reducing.py

 
 from math import fsum
 from threading import local
-from collections import Iterable
 from functools import partial, reduce
 from operator import contains, truediv
 from itertools import cycle, tee, islice
 
-from thingq.support import Counter, isstring, imap, zip
+from stuf.six import strings
+from thingq.support import Counter, imap, zip, ichain
 
 
 class MathMixin(local):
     '''math mixin'''
 
     def average(self):
-        '''average of all incoming things'''
+        '''average value of incoming things'''
         def average(iterable):
-            '''average of `iterable`'''
             i1, i2 = tee(iterable)
             return truediv(sum(i1, 0.0), len(list(i2)))
         with self._context():
             return self._append(average(self._iterable))
 
     def fsum(self):
-        '''add incoming things together'''
+        '''add incoming things together (if floats)'''
         with self._context():
             return self._append(fsum(self._iterable))
 
     def max(self):
         '''
-        find maximum thing in incoming things, optionally using current
-        call as key function
+        find maximum value among incoming things using current callable as key
+        function
         '''
         with self._context():
             return self._append(max(self._iterable, key=self._call))
 
     def median(self):
-        '''median of all incoming things'''
+        '''median value of incoming things'''
         def median(iterable):
-            '''median of `iterable`'''
             i = list(sorted(iterable))
             e = truediv(len(i) - 1, 2)
             p = int(e)
             return self._append(median(self._iterable))
 
     def min(self):
-        '''find minimum thing in incoming things using call as key function'''
+        '''
+        find minimum value among incoming things using current callable as key
+        function
+        '''
         with self._context():
             return self._append(min(self._iterable, key=self._call))
 
     def minmax(self):
-        '''minimum and maximum things among all incoming things'''
+        '''minimum and maximum values among incoming things'''
         with self._context():
             i1, i2 = tee(self._iterable)
             return self._xtend(iter([min(i1), max(i2)]))
 
-    def mode(self):
-        '''mode of all incoming things'''
-        with self._context():
-            return self._append(
-                Counter(self._iterable).most_common(1)[0][0]
-            )
-
     def statrange(self):
-        '''statistical range of all incoming things'''
+        '''statistical range of incoming things'''
         with self._context():
             iterz = list(sorted(self._iterable))
             return self._append(iterz[-1] - iterz[0])
 
     def sum(self, start=0):
         '''
-        add all incoming things together
+        total incoming things together
 
         @param start: starting number (default: 0)
         '''
         with self._context():
             return self._append(any(imap(self._call, self._iterable)))
 
+    def common(self):
+        '''mode value of incoming things'''
+        with self._context():
+            return self._append(
+                Counter(self._iterable).most_common(1)[0][0]
+            )
+
     def contains(self, thing):
         '''
         if `thing` is found in incoming things
             return self._append(Counter(self._iterable).most_common())
 
     def quantify(self):
-        '''how many times call is `True` for incoming things'''
+        '''
+        how many times current callable returns `True` for incoming things
+        '''
         with self._context():
             return self._append(sum(imap(self._call, self._iterable)))
 
 
     '''reduce mixin'''
 
+    def concat(self):
+        '''concatenate all incoming things together'''
+        with self._context():
+            return self._xtend(ichain(self._iterable))
+
     def flatten(self):
         '''flatten deeply nested incoming things'''
         def smash(iterable):
-            isstring_, Iterable_, smash_ = isstring, Iterable, smash
-            for i in iterable:
-                if isinstance(i, Iterable_) and not isstring_(i):
-                    for j in smash_(i):
-                        yield j
-                else:
-                    yield i
+            smash_ = smash
+            for item in iterable:
+                try:
+                    if isinstance(item, strings):
+                        yield item
+                    else:
+                        for j in smash_(item):
+                            yield j
+                except TypeError:
+                    yield item
         with self._context():
             return self._xtend(smash(self._iterable))
 
         '''
         with self._context():
             return self._xtend(zip(*self._iterable))
-
-
-class ReducingMixin(MathMixin, TruthMixin, ReduceMixin):
-
-    '''reducing mixin'''

File thingq/support.py

     reraise = staticmethod(six.reraise)
 
     @classmethod
-    def isbinary(cls, out):
+    def isbinary(cls, value):
         '''is binary?'''
-        return isinstance(out, cls.BINARY)
+        return isinstance(value, cls.BINARY)
 
     @classmethod
-    def isclass(cls, out):
+    def isclass(cls, value):
         '''is class?'''
-        return isinstance(out, cls.CLASS)
+        return isinstance(value, cls.CLASS)
 
     @classmethod
-    def iscall(cls, out):
+    def iscall(cls, value):
         '''is callable?'''
-        return six.callable(out)
+        return six.callable(value)
 
     @classmethod
-    def isgtemax(cls, out):
+    def isgtemax(cls, value):
         '''greater than max size?'''
-        return out > cls.MAXSIZE
+        return value > cls.MAXSIZE
 
     @classmethod
-    def isinteger(cls, out):
+    def isinteger(cls, value):
         '''is integer?'''
-        return isinstance(out, cls.INTEGER)
+        return isinstance(value, cls.INTEGER)
 
     @classmethod
-    def isltemax(cls, out):
+    def isltemax(cls, value):
         '''less than max size?'''
-        return out < cls.MAXSIZE
+        return value < cls.MAXSIZE
 
     @classmethod
-    def isstring(cls, out):
+    def isstring(cls, value):
         '''is string'''
-        return isinstance(out, cls.STRING)
+        return isinstance(value, cls.STRING)
 
     @classmethod
-    def isunicode(cls, out):
+    def isunicode(cls, value):
         '''is text?'''
-        return isinstance(out, cls.UNICODE)
+        return isinstance(value, cls.UNICODE)
 
     @staticmethod
     def printf(*args, **kw):

File thingq/tests/active/__init__.py

-# -*- coding: utf-8 -*-
-'''active queue tests'''

File thingq/tests/active/auto/__init__.py

-# -*- coding: utf-8 -*-
-'''active automatic queues tests'''

File thingq/tests/active/auto/test_autoq.py

-# -*- coding: utf-8 -*-
-'''autoq tests'''
-
-try:
-    import unittest2 as unittest
-except ImportError:
-    import unittest
-
-from thingq.tests.auto.queuing import AQMixin
-from thingq.tests.auto.mapping import AMapQMixin
-from thingq.tests.auto.ordering import AOrderQMixin
-from thingq.tests.auto.reducing import AReduceQMixin
-from thingq.tests.auto.filtering import AFilterQMixin
-
-
-class TestAutoQ(
-    unittest.TestCase, AQMixin, AFilterQMixin, AMapQMixin, AReduceQMixin,
-    AOrderQMixin,
-):
-
-    def setUp(self):
-        from thingq import autoq
-        self.qclass = autoq
-
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/active/auto/test_filtering.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-from thingq.tests.auto.filtering import *  # @UnusedWildImport
-from thingq.tests.auto.queuing import AQMixin
-
-
-class TestAutoFilterQ(unittest.TestCase, AQMixin, AFilterQMixin):
-
-    def setUp(self):
-        self.maxDiff = None
-        from thingq.active.filtering import filterq
-        self.qclass = filterq
-
-
-class TestAutoSliceQ(unittest.TestCase, AQMixin, ASliceQMixin):
-
-    def setUp(self):
-        from thingq.active.filtering import sliceq
-        self.qclass = sliceq
-
-
-class TestAutoCollectQ(unittest.TestCase, AQMixin, ACollectQMixin):
-
-    def setUp(self):
-        self.maxDiff = None
-        from thingq.active.filtering import collectq
-        self.qclass = collectq
-
-
-class TestAutoSetQ(unittest.TestCase, AQMixin, ASetQMixin):
-
-    def setUp(self):
-        from thingq.active.filtering import setq
-        self.qclass = setq
-
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/active/auto/test_mapping.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-from thingq.tests.auto.mapping import *  # @UnusedWildImport
-from thingq.tests.auto.queuing import AQMixin
-
-
-class TestAutoMap(unittest.TestCase, AQMixin, AMapQMixin):
-
-    def setUp(self):
-        from thingq.active.mapping import mapq
-        self.qclass = mapq
-
-
-class TestAutoRepeatQ(unittest.TestCase, AQMixin, ARepeatQMixin):
-
-    def setUp(self):
-        from thingq.active.mapping import repeatq
-        self.qclass = repeatq
-
-
-class TestAutoDelayQ(unittest.TestCase, AQMixin, ADelayQMixin):
-
-    def setUp(self):
-        from thingq.active.mapping import delayq
-        self.qclass = delayq
-
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/active/auto/test_ordering.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-#pylint: disable-msg=w0614,w0401
-from thingq.tests.auto.ordering import *  # @UnusedWildImport
-from thingq.tests.auto.queuing import AQMixin
-
-
-class TestAutoOrderQ(unittest.TestCase, AQMixin, AOrderQMixin):
-
-    def setUp(self):
-        from thingq.active.ordering import orderq
-        self.qclass = orderq
-
-
-class TestAutoRandomQ(unittest.TestCase, AQMixin, ARandomQMixin):
-
-    def setUp(self):
-        from thingq.active.ordering import randomq
-        self.qclass = randomq
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/active/auto/test_reducing.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-#pylint: disable-msg=w0614,w0401
-from thingq.tests.auto.reducing import *  # @UnusedWildImport
-from thingq.tests.auto.queuing import AQMixin
-
-
-class TestAutoReduceQ(unittest.TestCase, AQMixin, AReduceQMixin):
-
-    def setUp(self):
-        from thingq.active.reducing import reduceq
-        self.qclass = reduceq
-
-
-class TestAutoMathQ(unittest.TestCase, AQMixin, AMathQMixin):
-
-    def setUp(self):
-        from thingq.active.reducing import mathq
-        self.qclass = mathq
-
-
-class TestAutoTruthQ(unittest.TestCase, AQMixin, ATruthQMixin):
-
-    def setUp(self):
-        from thingq.active.reducing import truthq
-        self.qclass = truthq
-
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/active/man/__init__.py

-# -*- coding: utf-8 -*-
-'''active manual queues tests'''

File thingq/tests/active/man/test_filtering.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-#pylint: disable-msg=w0614,w0401
-from thingq.tests.man.filtering import *  # @UnusedWildImport
-from thingq.tests.man.manning import Manning
-from thingq.tests.man.queuing import MQMixin
-
-
-class TestManFilterQ(Manning, MFilterQMixin):
-
-    def setUp(self):
-        self.maxDiff = None
-        from thingq.active.filtering import mfilterq
-        self.qclass = mfilterq
-
-
-class TestManSliceQ(Manning, MQMixin, MSliceQMixin):
-
-    def setUp(self):
-        from thingq.active.filtering import msliceq
-        self.qclass = msliceq
-
-
-class TestManCollectQ(Manning, MQMixin, MCollectQMixin):
-
-    def setUp(self):
-        from thingq.active.filtering import mcollectq
-        self.qclass = mcollectq
-
-
-class TestManSetQ(Manning, MQMixin, MSetQMixin):
-
-    def setUp(self):
-        from thingq.active.filtering import msetq
-        self.qclass = msetq
-
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/active/man/test_manq.py

-# -*- coding: utf-8 -*-
-'''manq tests'''
-
-from thingq.support import unittest
-from thingq.tests.man.manning import Manning
-from thingq.tests.man.queuing import MQMixin
-from thingq.tests.man.mapping import MMapQMixin
-from thingq.tests.man.ordering import MOrderQMixin
-from thingq.tests.man.reducing import MReduceQMixin
-from thingq.tests.man.filtering import MFilterQMixin
-
-
-class TestManQ(
-    Manning, MQMixin, MFilterQMixin, MMapQMixin, MReduceQMixin, MOrderQMixin,
-):
-
-    def setUp(self):
-        from thingq import manq
-        self.qclass = manq
-
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/active/man/test_mapping.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-#pylint: disable-msg=w0614,w0401
-from thingq.tests.man.mapping import *  # @UnusedWildImport
-from thingq.tests.man.manning import Manning
-from thingq.tests.man.queuing import MQMixin
-
-
-class TestManMap(Manning, MQMixin, MMapQMixin):
-
-    def setUp(self):
-        from thingq.active.mapping import mmapq
-        self.qclass = mmapq
-
-
-class TestManRepeatQ(Manning, MQMixin, MRepeatQMixin):
-
-    def setUp(self):
-        from thingq.active.mapping import mrepeatq
-        self.qclass = mrepeatq
-
-
-class TestManDelayQ(Manning, MQMixin, MDelayQMixin):
-
-    def setUp(self):
-        from thingq.active.mapping import mdelayq
-        self.qclass = mdelayq
-
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/active/man/test_ordering.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-#pylint: disable-msg=w0614,w0401
-from thingq.tests.man.ordering import *  # @UnusedWildImport
-from thingq.tests.man.manning import Manning
-from thingq.tests.man.queuing import MQMixin
-
-
-class TestManOrderQ(Manning, MQMixin, MOrderQMixin):
-
-    def setUp(self):
-        from thingq.active.ordering import morderq
-        self.qclass = morderq
-
-
-class TestManRandomQ(Manning, MQMixin, MRandomQMixin):
-
-    def setUp(self):
-        from thingq.active.ordering import mrandomq
-        self.qclass = mrandomq
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/active/man/test_reducing.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-#pylint: disable-msg=w0614,w0401
-from thingq.tests.man.reducing import *  # @UnusedWildImport
-from thingq.tests.man.manning import Manning
-from thingq.tests.man.queuing import MQMixin
-
-
-class TestManReduceQ(Manning, MQMixin, MReduceQMixin):
-
-    def setUp(self):
-        from thingq.active.reducing import mreduceq
-        self.qclass = mreduceq
-
-
-class TestManMathQ(Manning, MQMixin, MMathQMixin):
-
-    def setUp(self):
-        from thingq.active.reducing import mmathq
-        self.qclass = mmathq
-
-
-class TestManTruthQ(Manning, MQMixin, MTruthQMixin):
-
-    def setUp(self):
-        from thingq.active.reducing import mtruthq
-        self.qclass = mtruthq
-
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/auto/mapping.py

         self.assertListEqual(newlist[1], testlist[1])
 
 
-class ADelayQMixin(object):
-
-    def test_delay_each(self):
-        def test(*args, **kw):
-            return sum(args) * kw['a']
-        self.assertEqual(
-            self.qclass(
-                ((1, 2), {'a': 2}), ((2, 3), {'a': 2}), ((3, 4), {'a': 2})
-            ).tap(test).delay_each(0.0001).end(),
-            [6, 10, 14],
-        )
-
-    def test_delay_map(self):
-        self.assertEqual(
-            self.qclass(1, 2, 3).tap(lambda x: x * 3).delay_map(0.0001).end(),
-            [3, 6, 9],
-        )
-
-    def test_delay_invoke(self):
-        self.assertEqual(
-            self.qclass([5, 1, 7], [3, 2, 1])
-            .args(1).delay_invoke('index', 0.0001).end(),
-            [1, 2],
-        )
-        self.assertEqual(
-            self.qclass(
-                [5, 1, 7], [3, 2, 1]
-            ).delay_invoke('sort', 0.0001).end(),
-            [[1, 5, 7], [1, 2, 3]],
-        )
-
-
-class AMapQMixin(ADelayQMixin, ARepeatQMixin):
+class AMapQMixin(ARepeatQMixin):
 
     def test_factory(self):
         from stuf import stuf
             ).tap(test).each().end(),
             [6, 10, 14],
         )
+        self.assertEqual(
+            self.qclass(
+                ((1, 2), {'a': 2}), ((2, 3), {'a': 2}), ((3, 4), {'a': 2})
+            ).tap(test).each(0.0001).end(),
+            [6, 10, 14],
+        )
 
     def test_map(self):
         self.assertEqual(
             self.qclass(1, 2, 3).tap(lambda x: x * 3).map().end(), [3, 6, 9],
         )
+        self.assertEqual(
+            self.qclass(1, 2, 3).tap(lambda x: x * 3).map(0.0001).end(),
+            [3, 6, 9],
+        )
 
     def test_starmap(self):
         self.assertEqual(
             self.qclass([5, 1, 7], [3, 2, 1]).invoke('sort').end(),
             [[1, 5, 7], [1, 2, 3]],
         )
-
+        self.assertEqual(
+            self.qclass([5, 1, 7], [3, 2, 1])
+            .args(1).invoke('index', 0.0001).end(),
+            [1, 2],
+        )
+        self.assertEqual(
+            self.qclass([5, 1, 7], [3, 2, 1]).invoke('sort', 0.0001).end(),
+            [[1, 5, 7], [1, 2, 3]],
+        )
 
 __all__ = sorted(name for name, obj in port.items(locals()) if not any([
     name.startswith('_'), ismodule(obj), name in ['ismodule', 'port']

File thingq/tests/auto/reducing.py

         self.assertEqual(self.qclass(4, 5, 7, 2, 1).median().end(), 4)
         self.assertEqual(self.qclass(4, 5, 7, 2, 1, 8).median().end(), 4.5)
 
-    def test_mode(self):
-        self.assertEqual(
-            self.qclass(11, 3, 5, 11, 7, 3, 11).mode().end(), 11,
-        )
-
     def test_statrange(self):
         self.assertEqual(self.qclass(3, 5, 7, 3, 11).statrange().end(), 8)
 
             self.qclass(None, 0, 'yes', False).tap(bool).quantify().end(), 1,
         )
 
+    def test_common(self):
+        self.assertEqual(
+            self.qclass(11, 3, 5, 11, 7, 3, 11).common().end(), 11,
+        )
+
     def test_uncommon(self):
         self.assertEqual(
             self.qclass(11, 3, 5, 11, 7, 3, 11).uncommon().end(), 7,
 
 
 class AReduceQMixin(AMathQMixin, ATruthQMixin):
+    
+    def test_concat(self):
+        self.assertEqual(
+            self.qclass([1, 2], [5, [3, 4]]).concat().end(),
+            [1, 2, 5, [3, 4]],
+        )   
 
     def test_flatten(self):
         self.assertEqual(

File thingq/tests/lazy/__init__.py

-# -*- coding: utf-8 -*-
-'''lazy queue tests'''

File thingq/tests/lazy/auto/__init__.py

-# -*- coding: utf-8 -*-
-'''lazy automatic queues tests'''

File thingq/tests/lazy/auto/test_autoq.py

-# -*- coding: utf-8 -*-
-'''autoq tests'''
-
-from thingq.support import unittest
-from thingq.tests.auto.queuing import AQMixin
-from thingq.tests.auto.mapping import AMapQMixin
-from thingq.tests.auto.ordering import AOrderQMixin
-from thingq.tests.auto.reducing import AReduceQMixin
-from thingq.tests.auto.filtering import AFilterQMixin
-
-
-class TestAutoQ(
-    unittest.TestCase, AQMixin, AFilterQMixin, AMapQMixin, AReduceQMixin,
-    AOrderQMixin,
-):
-
-    def setUp(self):
-        from thingq.lazy.core import autoq
-        self.qclass = autoq
-
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/lazy/auto/test_filtering.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-#pylint: disable-msg=w0614,w0401
-from thingq.tests.auto.filtering import *  # @UnusedWildImport
-from thingq.tests.auto.queuing import AQMixin
-
-
-class TestAutoFilterQ(unittest.TestCase, AQMixin, AFilterQMixin):
-
-    def setUp(self):
-        self.maxDiff = None
-        from thingq.lazy.filtering import filterq
-        self.qclass = filterq
-
-
-class TestAutoSliceQ(unittest.TestCase, AQMixin, ASliceQMixin):
-
-    def setUp(self):
-        from thingq.lazy.filtering import sliceq
-        self.qclass = sliceq
-
-
-class TestAutoCollectQ(unittest.TestCase, AQMixin, ACollectQMixin):
-
-    def setUp(self):
-        self.maxDiff = None
-        from thingq.lazy.filtering import collectq
-        self.qclass = collectq
-
-
-class TestAutoSetQ(unittest.TestCase, AQMixin, ASetQMixin):
-
-    def setUp(self):
-        from thingq.lazy.filtering import setq
-        self.qclass = setq
-
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/lazy/auto/test_mapping.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-#pylint: disable-msg=w0614,w0401
-from thingq.tests.auto.mapping import *  # @UnusedWildImport
-from thingq.tests.auto.queuing import AQMixin
-
-
-class TestAutoMap(unittest.TestCase, AQMixin, AMapQMixin):
-
-    def setUp(self):
-        from thingq.lazy.mapping import mapq
-        self.qclass = mapq
-
-
-class TestAutoRepeatQ(unittest.TestCase, AQMixin, ARepeatQMixin):
-
-    def setUp(self):
-        from thingq.lazy.mapping import repeatq
-        self.qclass = repeatq
-
-
-class TestAutoDelayQ(unittest.TestCase, AQMixin, ADelayQMixin):
-
-    def setUp(self):
-        from thingq.lazy.mapping import delayq
-        self.qclass = delayq
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/lazy/auto/test_ordering.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-#pylint: disable-msg=w0614,w0401
-from thingq.tests.auto.ordering import *  # @UnusedWildImport
-from thingq.tests.auto.queuing import AQMixin
-
-
-class TestAutoOrderQ(unittest.TestCase, AQMixin, AOrderQMixin):
-
-    def setUp(self):
-        from thingq.lazy.ordering import orderq
-        self.qclass = orderq
-
-
-class TestAutoRandomQ(unittest.TestCase, AQMixin, ARandomQMixin):
-
-    def setUp(self):
-        from thingq.lazy.ordering import randomq
-        self.qclass = randomq
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/lazy/auto/test_reducing.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-#pylint: disable-msg=w0614,w0401
-from thingq.tests.auto.reducing import *  # @UnusedWildImport
-from thingq.tests.auto.queuing import AQMixin
-
-
-class TestAutoReduceQ(unittest.TestCase, AQMixin, AReduceQMixin):
-
-    def setUp(self):
-        from thingq.lazy.reducing import reduceq
-        self.qclass = reduceq
-
-
-class TestAutoMathQ(unittest.TestCase, AQMixin, AMathQMixin):
-
-    def setUp(self):
-        from thingq.lazy.reducing import mathq
-        self.qclass = mathq
-
-
-class TestAutoTruthQ(unittest.TestCase, AQMixin, ATruthQMixin):
-
-    def setUp(self):
-        from thingq.lazy.reducing import truthq
-        self.qclass = truthq
-
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/lazy/man/__init__.py

-# -*- coding: utf-8 -*-
-'''lazy manual queues tests'''

File thingq/tests/lazy/man/test_filtering.py

-# -*- coding: utf-8 -*-
-
-from thingq.support import unittest
-#pylint: disable-msg=w0614,w0401
-from thingq.tests.man.filtering import *  # @UnusedWildImport
-from thingq.tests.man.manning import Manning
-from thingq.tests.man.queuing import MQMixin
-
-
-class TestManFilterQ(Manning, MFilterQMixin):
-
-    def setUp(self):
-        self.maxDiff = None
-        from thingq.lazy.filtering import mfilterq
-        self.qclass = mfilterq
-
-
-class TestManSliceQ(Manning, MQMixin, MSliceQMixin):
-
-    def setUp(self):
-        from thingq.lazy.filtering import msliceq
-        self.qclass = msliceq
-
-
-class TestManCollectQ(Manning, MQMixin, MCollectQMixin):
-
-    def setUp(self):
-        from thingq.lazy.filtering import mcollectq
-        self.qclass = mcollectq
-
-
-class TestManSetQ(Manning, MQMixin, MSetQMixin):
-
-    def setUp(self):
-        from thingq.lazy.filtering import msetq
-        self.qclass = msetq
-
-
-if __name__ == '__main__':
-    unittest.main()

File thingq/tests/lazy/man/test_manq.py

-# -*- coding: utf-8 -*-
-'''manq tests'''
-
-from thingq.support import unittest
-from thingq.tests.man.manning import Manning