##

# python.functools

##

import sys

from .decorlib import method

def rsetattr(attr, val, ob):

"""

setattr() and return `ob`. Different order used to allow easier partial

usage.

"""

setattr(ob, attr, val)

return ob

try:

from ..port.optimized import rsetattr

except ImportError:

pass

class Composition(tuple):

def __call__(self, r):

for x in self:

r = x(r)

return r

try:

from ..port.optimized import compose

__call__ = method(compose)

del compose

except ImportError:

pass

try:

# C implementation of the tuple processors.

from ..port.optimized import process_tuple, process_chunk

except ImportError:

def process_tuple(procs, tup, exception_handler, len = len, tuple = tuple, cause = None):

"""

Call each item in `procs` with the corresponding

item in `tup` returning the result as `type`.

If an item in `tup` is `None`, don't process it.

If a give transformation failes, call the given exception_handler.

"""

i = len(procs)

if len(tup) != i:

raise TypeError(

"inconsistent items, %d processors and %d items in row" %(

i, len(tup)

)

)

r = [None] * i

try:

for i in range(i):

ob = tup[i]

if ob is None:

continue

r[i] = procs[i](ob)

except Exception:

cause = sys.exc_info()[1]

if cause is not None:

exception_handler(cause, procs, tup, i)

raise RuntimeError("process_tuple exception handler failed to raise")

return tuple(r)

def process_chunk(procs, tupc, fail, process_tuple = process_tuple):

return [process_tuple(procs, x, fail) for x in tupc]