Python compatibility.callable函数代码示例

 def apply_to_curve(self, verts, u_set, set_len=None, inc_pos=None):
     """
     Apply this color scheme to a
     set of vertices over a single
     independent variable u.
     """
     bounds = create_bounds()
     cverts = list()
     if callable(set_len): set_len(len(u_set)*2)
     # calculate f() = r,g,b for each vert
     # and find the min and max for r,g,b
     for _u in xrange(len(u_set)):
         if verts[_u] is None:
             cverts.append(None)
         else:
             x,y,z = verts[_u]
             u,v = u_set[_u], None
             c = self(x,y,z,u,v)
             if c is not None:
                 c = list(c)
                 update_bounds(bounds, c)
             cverts.append(c)
         if callable(inc_pos): inc_pos()
     # scale and apply gradient
     for _u in xrange(len(u_set)):
         if cverts[_u] is not None:
             for _c in xrange(3):
                 # scale from [f_min, f_max] to [0,1]
                 cverts[_u][_c] = rinterpolate(bounds[_c][0], bounds[_c][1], cverts[_u][_c])
             # apply gradient
             cverts[_u] = self.gradient(*cverts[_u])
         if callable(inc_pos): inc_pos()
     return cverts

def check(a, check_attr=True):
    """ Check that pickling and copying round-trips.
    """
    # The below hasattr() check will warn about is_Real in Python 2.5, so
    # disable this to keep the tests clean
    warnings.filterwarnings("ignore", ".*is_Real.*")
    protocols = [0, 1, 2, copy.copy, copy.deepcopy]
    # Python 2.x doesn't support the third pickling protocol
    if sys.version_info[0] > 2:
        protocols.extend([3])
    for protocol in protocols:
        if callable(protocol):
            if isinstance(a, BasicType):
                # Classes can't be copied, but that's okay.
                return
            b = protocol(a)
        else:
            b = pickle.loads(pickle.dumps(a, protocol))

        d1 = dir(a)
        d2 = dir(b)
        assert d1==d2

        if not check_attr:
            continue
        def c(a, b, d):
            for i in d:
                if not hasattr(a, i) or i in excluded_attrs:
                    continue
                attr = getattr(a, i)
                if not hasattr(attr, "__call__"):
                    assert hasattr(b,i), i
                    assert getattr(b,i) == attr
        c(a,b,d1)
        c(b,a,d2)

def check(a, check_attr = True):
    """ Check that pickling and copying round-trips.
    """
    # The below hasattr() check will warn about is_Real in Python 2.5, so
    # disable this to keep the tests clean
    warnings.filterwarnings("ignore", ".*is_Real.*", DeprecationWarning)
    #FIXME-py3k: Add support for protocol 3.
    for protocol in [0, 1, 2, copy.copy, copy.deepcopy]:
        if callable(protocol):
            if isinstance(a, BasicType):
                # Classes can't be copied, but that's okay.
                return
            b = protocol(a)
        else:
            b = pickle.loads(pickle.dumps(a, protocol))

        d1 = dir(a)
        d2 = dir(b)
        assert d1==d2

        if not check_attr:
            continue
        def c(a,b,d):
            for i in d:
                if not hasattr(a,i):
                    continue
                attr = getattr(a,i)
                if not hasattr(attr, "__call__"):
                    assert hasattr(b,i), i
                    assert getattr(b,i)==attr
        c(a,b,d1)
        c(b,a,d2)

def check(a, check_attr = True):
    """ Check that pickling and copying round-trips.
    """
    for protocol in [0, 1, 2, copy.copy, copy.deepcopy]:
        if callable(protocol):
            if isinstance(a, BasicType):
                # Classes can't be copied, but that's okay.
                return
            b = protocol(a)
        else:
            b = pickle.loads(pickle.dumps(a, protocol))

        d1 = dir(a)
        d2 = dir(b)
        assert d1==d2

        if not check_attr:
            continue
        def c(a,b,d):
            for i in d:
                if not hasattr(a,i):
                    continue
                attr = getattr(a,i)
                if not hasattr(attr, "__call__"):
                    assert hasattr(b,i), i
                    assert getattr(b,i)==attr
        c(a,b,d1)
        c(b,a,d2)

 def _calculate_verts(self):
     if self._calculating_verts.isSet(): return
     self._calculating_verts.set()
     try: self._on_calculate_verts()
     finally: self._calculating_verts.clear()
     if callable(self.bounds_callback):
         self.bounds_callback()

 def _test_color_function(self):
     if not callable(self.f):
         raise ValueError("Color function is not callable.")
     try:
         result = self.f(0, 0, 0, 0, 0)
         assert len(result) == 3
     except TypeError, te:
         raise ValueError("Color function needs to accept x,y,z,u,v, "
                          "as arguments even if it doesn't use all of them.")

 def example(i):
     if callable(i):
         p.clear()
         i()
     elif i >= 0 and i < len(examples):
         p.clear()
         examples[i]()
     else: print "Not a valid example.\n"
     print p

 def draw(self):
     for f in self.predraw:
         if callable(f): f()
     if self.style_override:
         style = self.styles[self.style_override]
     else:
         style = self.styles[self._style]
     # Draw solid component if style includes solid
     if style & 2:
         dl = self._render_stack_top(self._draw_solid)
         if dl > 0 and GL_TRUE == glIsList(dl):
             self._draw_solid_display_list(dl)
     # Draw wireframe component if style includes wireframe
     if style & 1:
         dl = self._render_stack_top(self._draw_wireframe)
         if dl > 0 and GL_TRUE == glIsList(dl):
             self._draw_wireframe_display_list(dl)
     for f in self.postdraw:
         if callable(f): f()

 def push_solid(self, function):
     """
     Push a function which performs gl commands
     used to build a display list. (The list is
     built outside of the function)
     """
     assert callable(function)
     self._draw_solid.append(function)
     if len(self._draw_solid) > self._max_render_stack_size:
         del self._draw_solid[1] # leave marker element

 def _test_color_function(self):
     if not callable(self.f):
         raise ValueError("Color function is not callable.")
     try:
         result = self.f(0, 0, 0, 0, 0)
         assert len(result) == 3
     except TypeError as te:
         raise ValueError("Color function needs to accept x,y,z,u,v, "
                          "as arguments even if it doesn't use all of them.")
     except AssertionError as ae:
         raise ValueError("Color function needs to return 3-tuple r,g,b.")
     except Exception as ie:
         pass  # color function probably not valid at 0,0,0,0,0

 def _eval_args(cls, args):
     if len(args) != 2:
         raise QuantumError(
             'Insufficient/excessive arguments to Oracle.  Please ' +
                 'supply the number of qubits and an unknown function.'
         )
     sub_args = args[0],
     sub_args = UnitaryOperator._eval_args(sub_args)
     if not sub_args[0].is_Integer:
         raise TypeError('Integer expected, got: %r' % sub_args[0])
     if not callable(args[1]):
         raise TypeError('Callable expected, got: %r' % args[1])
     sub_args = UnitaryOperator._eval_args(tuple(range(args[0])))
     return (sub_args, args[1])

 def _render_stack_top(self, render_stack):
     top = render_stack[-1]
     if top == -1:
         return -1 # nothing to display
     elif callable(top):
         dl = self._create_display_list(top)
         render_stack[-1] = (dl, top)
         return dl # display newly added list
     elif len(top) == 2:
         if GL_TRUE == glIsList(top[0]):
             return top[0] # display stored list
         dl = self._create_display_list(top[1])
         render_stack[-1] = (dl, top[1])
         return dl # display regenerated list

def get_class(lookup_view):
    """
    Convert a string version of a class name to the object.

    For example, get_class('sympy.core.Basic') will return
    class Basic located in module sympy.core
    """
    if isinstance(lookup_view, str):
        lookup_view = lookup_view
        mod_name, func_name = get_mod_func(lookup_view)
        if func_name != "":
            lookup_view = getattr(__import__(mod_name, {}, {}, [""]), func_name)
            if not callable(lookup_view):
                raise AttributeError("'%s.%s' is not a callable." % (mod_name, func_name))
    return lookup_view

def get_class(lookup_view):
    """
    Convert a string version of a class name to the object.

    For example, get_class('sympy.core.Basic') will return
    class Basic located in module sympy.core
    """
    if isinstance(lookup_view, str):
        # Bail early for non-ASCII strings (they can't be functions).
        lookup_view = lookup_view.encode('ascii')
        mod_name, func_name = get_mod_func(lookup_view)
        if func_name != '':
            lookup_view = getattr(__import__(mod_name, {}, {}, ['']), func_name)
            if not callable(lookup_view):
                raise AttributeError("'%s.%s' is not a callable." % (mod_name, func_name))
    return lookup_view

    def __init__(self, *args, **kwargs):
        self.args = args
        self.f, self.gradient = None, ColorGradient()

        if len(args) == 1 and not isinstance(args[0], Basic) and callable(args[0]):
            self.f = args[0]
        elif len(args) == 1 and isinstance(args[0], str):
            if args[0] in default_color_schemes:
                cs = default_color_schemes[args[0]]
                self.f, self.gradient = cs.f, cs.gradient.copy()
            else:
                self.f = lambdify('x,y,z,u,v', args[0])
        else:
            self.f, self.gradient = self._interpret_args(args, kwargs)
        self._test_color_function()
        if not isinstance(self.gradient, ColorGradient):
            raise ValueError("Color gradient not properly initialized. "
                             "(Not a ColorGradient instance.)")