Example #1
0
 def addMethods(self):
     # Add the auxiliary function specs to this Generator's namespace
     for auxfnname in self.funcspec._pyauxfns:
         fninfo = self.funcspec._pyauxfns[auxfnname]
         if not hasattr(self, fninfo[1]):
             # user-defined auxiliary functions
             # (built-ins are provided explicitly)
             if self._solver:
                 fnstr = fninfo[0].replace(self._solver.name, "ds._solver")
             ##                    self._funcreg[self._solver.name] = self._solver
             else:
                 fnstr = fninfo[0]
             try:
                 exec(fnstr)
             except:
                 print("Error in supplied auxiliary function code")
             self._funcreg[fninfo[1]] = ("self", fnstr)
             setattr(self, fninfo[1], six.create_bound_method(locals()[fninfo[1]], self))
             # user auxiliary function interface wrapper
             try:
                 uafi_code = self.funcspec._user_auxfn_interface[auxfnname]
                 try:
                     exec(uafi_code)
                 except:
                     print("Error in auxiliary function wrapper")
                     raise
                 setattr(self.auxfns, auxfnname, six.create_bound_method(locals()[auxfnname], self.auxfns))
                 self._funcreg[auxfnname] = ("", uafi_code)
             except KeyError:
                 # not a user-defined aux fn
                 pass
     if self.funcspec.targetlang == "python":
         # Add the spec function to this Generator's namespace
         fninfo = self.funcspec.spec
         if self._solver:
             fnstr = fninfo[0].replace(self._solver.name, "ds._solver")
         else:
             fnstr = fninfo[0]
         try:
             exec(fnstr)
         except:
             print("Error in supplied functional specification code")
             raise
         self._funcreg[fninfo[1]] = ("self", fnstr)
         setattr(self, fninfo[1], six.create_bound_method(locals()[fninfo[1]], self))
         # Add the auxiliary spec function (if present) to this
         # Generator's namespace
         if self.funcspec.auxspec != "":
             fninfo = self.funcspec.auxspec
             if self._solver:
                 fnstr = fninfo[0].replace(self._solver.name, "ds._solver")
             else:
                 fnstr = fninfo[0]
             try:
                 exec(fnstr)
             except:
                 print("Error in supplied auxiliary variable code")
                 raise
             self._funcreg[fninfo[1]] = ("self", fnstr)
             setattr(self, fninfo[1], six.create_bound_method(locals()[fninfo[1]], self))
Example #2
0
    def addMethods(self):
        """Add Python-specific functions to this object's methods."""

        # Add the auxiliary function specs to this Generator's namespace
        for auxfnname in self.funcspec._pyauxfns:
            fninfo = self.funcspec._pyauxfns[auxfnname]
            if not hasattr(self, fninfo[1]):
                # user-defined auxiliary functions
                # (built-ins are provided explicitly)
                try:
                    exec(fninfo[0])
                except:
                    print('Error in supplied auxiliary function code')
                self._funcreg[fninfo[1]] = ('self', fninfo[0])
                setattr(self, fninfo[1],
                        six.create_bound_method(locals()[fninfo[1]], self))
                # user auxiliary function interface wrapper
                try:
                    uafi_code = self.funcspec._user_auxfn_interface[auxfnname]
                    try:
                        exec(uafi_code)
                    except:
                        print('Error in auxiliary function wrapper')
                        raise
                    setattr(
                        self.auxfns, auxfnname,
                        six.create_bound_method(locals()[auxfnname],
                                                self.auxfns))
                    self._funcreg[auxfnname] = ('', uafi_code)
                except KeyError:
                    # not a user-defined aux fn
                    pass
        # Add the spec function to this Generator's namespace if
        # target language is python (otherwise integrator exposes it anyway)
        if self.funcspec.targetlang == 'python':
            fninfo = self.funcspec.spec
            try:
                exec(fninfo[0])
            except:
                print('Error in supplied functional specification code')
                raise
            self._funcreg[fninfo[1]] = ('self', fninfo[0])
            setattr(self, fninfo[1],
                    six.create_bound_method(locals()[fninfo[1]], self))
            # Add the auxiliary spec function (if present) to this
            # Generator's namespace
            if self.funcspec.auxspec != '':
                fninfo = self.funcspec.auxspec
                try:
                    exec(fninfo[0])
                except:
                    print('Error in supplied auxiliary variable code')
                    raise
                self._funcreg[fninfo[1]] = ('self', fninfo[0])
                setattr(self, fninfo[1],
                        six.create_bound_method(locals()[fninfo[1]], self))
Example #3
0
    def cypher_prop(self):
        # noinspection PyUnresolvedReferences
        from py2neo.neo4j import CypherQuery

        cypher_ns = SimpleNamespace()
        cypher_ns.stream = six.create_bound_method(
            lambda s, q, **ps: CypherQuery(s, q).stream(**ps), self.graph_db)
        cypher_ns.execute = six.create_bound_method(
            lambda s, q, **ps: CypherQuery(s, q).execute(**ps), self.graph_db)
        return cypher_ns
Example #4
0
    def __init__(self, in_attrs, client):
        """Construct a resource

        :param in_attrs: A dictionary of attributes, usually obtained from a
        JSON response.
        :param client: an instance of gocardless.Client
        """
        attrs = in_attrs.copy()
        self._raw_attrs = attrs.copy()
        self.id = attrs["id"]
        self.client = client
        if "sub_resource_uris" in attrs:
            #For each subresource_uri create a method which grabs data
            #from the URI and uses it to instantiate the relevant class
            #and return it.
            for name, uri in six.iteritems(attrs.pop("sub_resource_uris")):
                path = re.sub(".*/api/v1", "", uri)
                sub_klass = self._get_klass_from_name(name)
                def create_get_resource_func(the_path, the_klass):
                    # In python functions close over their environment so in
                    # order to create the correct closure we need a function
                    # creator, see
                    # http://stackoverflow.com/questions/233673/
                    #         lexical-closures-in-python/235764#235764
                    def get_resources(inst, **params):
                        data = inst.client.api_get(the_path, params=params)
                        return [the_klass(attrs, self.client) for attrs in data]
                    return get_resources
                res_func = create_get_resource_func(path, sub_klass)
                func_name = "{0}".format(name)
                res_func.name = func_name
                setattr(self, func_name,
                        six.create_bound_method(res_func, self))

        for fieldname in self.date_fields:
            val = attrs.pop(fieldname)
            if val is not None:
                setattr(self, fieldname,
                        datetime.datetime.strptime(val, "%Y-%m-%dT%H:%M:%SZ"))
            else:
                setattr(self, fieldname, None)

        for fieldname in self.reference_fields:
            id = attrs.pop(fieldname)
            def create_get_func(the_klass, the_id):
                def get_referenced_resource(inst):
                    return the_klass.find_with_client(the_id, self.client)
                return get_referenced_resource
            name = fieldname.replace("_id", "")
            klass = self._get_klass_from_name(name)
            func = create_get_func(klass, id)
            setattr(self, name, six.create_bound_method(func, self))

        for key, value in six.iteritems(attrs):
            setattr(self, key, value)
Example #5
0
    def addMethods(self):
        """Add Python-specific functions to this object's methods."""

        # Add the auxiliary function specs to this Generator's namespace
        for auxfnname in self.funcspec._pyauxfns:
            fninfo = self.funcspec._pyauxfns[auxfnname]
            if not hasattr(self, fninfo[1]):
                # user-defined auxiliary functions
                # (built-ins are provided explicitly)
                try:
                    exec(fninfo[0])
                except:
                    print('Error in supplied auxiliary function code')
                self._funcreg[fninfo[1]] = ('self', fninfo[0])
                setattr(self, fninfo[1], six.create_bound_method(locals()[fninfo[1]], self))
                # user auxiliary function interface wrapper
                try:
                    uafi_code = self.funcspec._user_auxfn_interface[auxfnname]
                    try:
                        exec(uafi_code)
                    except:
                        print('Error in auxiliary function wrapper')
                        raise
                    setattr(self.auxfns, auxfnname,
                            six.create_bound_method(locals()[auxfnname], self.auxfns))
                    self._funcreg[auxfnname] = ('', uafi_code)
                except KeyError:
                    # not a user-defined aux fn
                    pass
        # Add the spec function to this Generator's namespace if
        # target language is python (otherwise integrator exposes it anyway)
        if self.funcspec.targetlang == 'python':
            fninfo = self.funcspec.spec
            try:
                exec(fninfo[0])
            except:
                print('Error in supplied functional specification code')
                raise
            self._funcreg[fninfo[1]] = ('self', fninfo[0])
            setattr(self, fninfo[1], six.create_bound_method(locals()[fninfo[1]], self))
            # Add the auxiliary spec function (if present) to this
            # Generator's namespace
            if self.funcspec.auxspec != '':
                fninfo = self.funcspec.auxspec
                try:
                    exec(fninfo[0])
                except:
                    print('Error in supplied auxiliary variable code')
                    raise
                self._funcreg[fninfo[1]] = ('self', fninfo[0])
                setattr(self, fninfo[1], six.create_bound_method(locals()[fninfo[1]], self))
def create_multi_node_evaluator(actual_evaluator, communicator):
    """Create a multi node evaluator from a normal evaluator.

    Actually this method patches the evaluator to work in multi node
    environment. This method adds several hidden attributes starting
    with `_mn_` prefix.

    Args:
        actual_evaluator: evaluator to be patched
            (e.g., ``chainer.training.extensions.Evaluator``)
        communicator: ChainerMN communicator

    Returns:
        The multi-node patched ``actual_evaluator``.

    .. note:: After patched, original evaluator does not work
              correctly in non-MPI environment.

    """

    actual_evaluator._mn_original_evaluate = actual_evaluator.evaluate
    actual_evaluator._mn_communicator = communicator

    def new_evaluate(self):
        local_mean_dict = self._mn_original_evaluate()

        # ChainerX support:
        # We need convert chainerx ndarray to Native array because
        #   (1) allreduce_obj is used to compute global mean values, since
        #       a simple allreduce operation cannot be applied in evaluation.
        #   (2) allreduce_obj calls mpi4py.allreduce, which pickles the object
        #   (3) chainerx.ndarray preserves CUDA device internally when pickled
        #   (4) An error will occur when an ndarray is unpickled in another
        #       process
        arrays = list(local_mean_dict.values())
        if len(arrays) > 0:
            array0 = list(local_mean_dict.values())[0]
            xp = backend.get_array_module(array0)
            if xp == chx and array0.device.backend.name == 'cuda':
                # Results of evaluation is fairly small, so
                # the ndarray is transferred to CPU and allreduce()-ed.
                # NOTE: Matrices for evaluation are transferred to the
                # host memory and sent via MPI instead of NCCL.
                # Although evaluation matrices are small in most cases,
                # this is a potential performance issue.
                local_mean_dict = {
                    name: chx.to_numpy(value)
                    for name, value in local_mean_dict.items()
                }

        global_mean_dict = {
            name: self._mn_communicator.allreduce_obj(value) /
            self._mn_communicator.size
            for name, value in sorted(local_mean_dict.items())
        }
        return global_mean_dict

    actual_evaluator.evaluate = six.create_bound_method(
        new_evaluate, actual_evaluator)
    return actual_evaluator
Example #7
0
    def __getattr__(self, name):
        fun = None
        if re.match("__.*__", name):
            # This is a python internal name, skip it
            raise AttributeError

        # try it bare
        llib = getattr(self, "lib")
        try:
            fun = getattr(llib, name)
        except AttributeError:
            for prefix in self.prefixes:
                try:
                    # wrap it
                    fun = getattr(llib, prefix + name)
                    break
                except AttributeError:
                    pass
        if fun is None:
            # Return a proxy class to generate a good error on call
            error_printer = ErrorPrinter(name, self.prefixes)
            setattr(self, name, error_printer)
            return error_printer

        if not callable(fun):  # pragma: no cover
            setattr(self, name, fun)
            return fun

        new_fun = self.check_wrap(fun, name)
        new_method = six.create_bound_method(new_fun, self)

        # Store the wrapper function into the instance
        # to prevent a second lookup
        setattr(self, name, new_method)
        return new_method
Example #8
0
    def test_365_calendar(self):
        f = mock.MagicMock(lbtim=SplittableInt(4, {
            'ia': 2,
            'ib': 1,
            'ic': 0
        }),
                           lbyr=2013,
                           lbmon=1,
                           lbdat=1,
                           lbhr=12,
                           lbmin=0,
                           lbsec=0,
                           t1=cftime.datetime(2013, 1, 1, 12, 0, 0),
                           t2=cftime.datetime(2013, 1, 2, 12, 0, 0),
                           spec=PPField3)
        f.time_unit = six.create_bound_method(PPField3.time_unit, f)
        f.calendar = cf_units.CALENDAR_365_DAY
        (factories, references, standard_name, long_name, units, attributes,
         cell_methods, dim_coords_and_dims, aux_coords_and_dims) = convert(f)

        def is_t_coord(coord_and_dims):
            coord, dims = coord_and_dims
            return coord.standard_name == 'time'

        coords_and_dims = list(filter(is_t_coord, aux_coords_and_dims))
        self.assertEqual(len(coords_and_dims), 1)
        coord, dims = coords_and_dims[0]
        self.assertEqual(guess_coord_axis(coord), 'T')
        self.assertEqual(coord.units.calendar, '365_day')
Example #9
0
    def test_365_calendar(self):
        f = mock.MagicMock(
            lbtim=SplittableInt(4, {"ia": 2, "ib": 1, "ic": 0}),
            lbyr=2013,
            lbmon=1,
            lbdat=1,
            lbhr=12,
            lbmin=0,
            lbsec=0,
            spec=PPField3,
        )
        f.time_unit = six.create_bound_method(PPField3.time_unit, f)
        f.calendar = cf_units.CALENDAR_365_DAY
        (
            factories,
            references,
            standard_name,
            long_name,
            units,
            attributes,
            cell_methods,
            dim_coords_and_dims,
            aux_coords_and_dims,
        ) = convert(f)

        def is_t_coord(coord_and_dims):
            coord, dims = coord_and_dims
            return coord.standard_name == "time"

        coords_and_dims = list(filter(is_t_coord, aux_coords_and_dims))
        self.assertEqual(len(coords_and_dims), 1)
        coord, dims = coords_and_dims[0]
        self.assertEqual(guess_coord_axis(coord), "T")
        self.assertEqual(coord.units.calendar, "365_day")
Example #10
0
    def __getattr__(self, name):
        fun = None
        if re.match("__.*__", name):
            # This is a python internal name, skip it
            raise AttributeError

        # try it bare
        llib = getattr(self, "lib")
        try:
            fun = getattr(llib, name)
        except AttributeError:
            for prefix in self.prefixes:
                try:
                    # wrap it
                    fun = getattr(llib, prefix + name)
                    break
                except AttributeError:
                    pass
        if fun is None:
            # Return a proxy class to generate a good error on call
            error_printer = ErrorPrinter(name, self.prefixes)
            setattr(self, name, error_printer)
            return error_printer

        if not callable(fun):  # pragma: no cover
            setattr(self, name, fun)
            return fun

        new_fun = self.check_wrap(fun, name)
        new_method = six.create_bound_method(new_fun, self)

        # Store the wrapper function into the instance
        # to prevent a second lookup
        setattr(self, name, new_method)
        return new_method
Example #11
0
    def get_request(self,
                    package=None,
                    perms="",
                    user=None,
                    use_base_url=False,
                    path=None):
        """ Construct a fake request """
        request = MagicMock()
        request.registry.fallback = self.fallback
        request.registry.always_show_upstream = self.always_show_upstream
        request.registry.fallback_url = self.fallback_url
        request.registry.fallback_base_url = (self.fallback_base_url
                                              if use_base_url else None)
        request.userid = user
        request.access.can_update_cache = lambda: "c" in perms
        request.access.has_permission.side_effect = lambda n, p: "r" in perms
        request.is_logged_in = user is not None
        request.request_login = six.create_bound_method(
            _request_login, request)
        pkgs = []
        if package is not None:
            pkgs.append(package)

        if path is not None:
            request.path = path

        request.db.all.return_value = pkgs
        return request
 def load(Class, path):
     if not exists(path):
         raise IOError
     if path.endswith('.zip'):
         import geometryIO
         from crosscompute_table import pandas as pd
         [
             proj4,
             geometries,
             field_packs,
             field_definitions,
         ] = geometryIO.load(path)
         # Convert to (longitude, latitude)
         normalize_geometry = geometryIO.get_transformGeometry(
             proj4 or geometryIO.proj4LL)
         geometries = [normalize_geometry(x) for x in geometries]
         # Convert to (latitude, longitude)
         geometries = transform_geometries(geometries, drop_z)
         geometries = transform_geometries(geometries, flip_xy)
         # Generate table
         table = pd.DataFrame(
             field_packs, columns=[x[0] for x in field_definitions])
         table['WKT'] = [x.wkt for x in geometries]
     else:
         table = super(GeotableType, Class).load(path)
     # TODO: Consider whether there is a better way to do this
     table.interpret = create_bound_method(_interpret, table)
     return table
Example #13
0
def create_multi_node_evaluator(actual_evaluator, communicator):
    """Create a multi node evaluator from a normal evaluator.

    Actually this method patches the evaluator to work in multi node
    environment. This method adds several hidden attributes starting
    with `_mn_` prefix.

    Args:
        actual_evaluator: evaluator to be patched
            (e.g., ``chainer.training.extensions.Evaluator``)
        communicator: ChainerMN communicator

    Returns:
        The multi-node patched ``actual_evaluator``.

    .. note:: After patched, original evaluator does not work
              correctly in non-MPI environment.

    """

    actual_evaluator._mn_original_evaluate = actual_evaluator.evaluate
    actual_evaluator._mn_communicator = communicator

    def new_evaluate(self):
        local_mean_dict = self._mn_original_evaluate()
        global_mean_dict = {
            name: self._mn_communicator.allreduce_obj(value) /
            self._mn_communicator.size
            for name, value in sorted(local_mean_dict.items())
        }
        return global_mean_dict

    actual_evaluator.evaluate = six.create_bound_method(
        new_evaluate, actual_evaluator)
    return actual_evaluator
Example #14
0
    def get_request(
        self, package=None, perms="", user=None, use_base_url=False, path=None
    ):
        """ Construct a fake request """
        request = MagicMock()
        request.registry.fallback = self.fallback
        request.registry.always_show_upstream = self.always_show_upstream
        request.registry.fallback_url = self.fallback_url
        request.registry.fallback_base_url = (
            self.fallback_base_url if use_base_url else None
        )
        request.userid = user
        request.access.can_update_cache = lambda: "c" in perms
        request.access.has_permission.side_effect = lambda n, p: "r" in perms
        request.is_logged_in = user is not None
        request.request_login = six.create_bound_method(_request_login, request)
        pkgs = []
        if package is not None:
            pkgs.append(package)

        if path is not None:
            request.path = path

        request.db.all.return_value = pkgs
        return request
Example #15
0
    def __get__(self, instance, owner):
        if not self.registry.get(instance, False):
            method = create_bound_method(self.method, instance)
            self.registry[instance] = listener = MethodProxy(method)
        else:
            listener = self.registry[instance]

        return listener
Example #16
0
 def __init__(self, suite, processes, failfast):
     # type: (TestSuite, int, bool) -> None
     super(ParallelTestSuite, self).__init__(suite, processes, failfast)
     self.subsuites = SubSuiteList(self.subsuites)  # type: SubSuiteList
     # ParallelTestSuite expects this to be a bound method so it can access
     # __func__ when passing it to multiprocessing.
     method = partial(run_subsuite, suite.collect_coverage)
     self.run_subsuite = six.create_bound_method(cast(types.FunctionType, method), self)
Example #17
0
    def createResource(self, name, lockType):
        s = six.StringIO("%s:%s" % (name, lockType))
        s.seek(0)

        def switchLockType(self, lockType):
            raise Exception("I NEVER SWITCH!!!")

        s.switchLockType = six.create_bound_method(switchLockType, s)
        return s
Example #18
0
    def bind_default_handler(self, obj, name):
        """Bind the default handler method to `obj` as attribute `name`.

        This could also be implemented as a mixin class.
        """
        assert self.default_handler is not None, '%s has no default handler method, cannot bind' % self.__class__.__name__
        setattr(obj, name, six.create_bound_method(self.default_handler, obj))
        log.debug("Bound default message handler '%s.%s' to %s", self.__class__.__name__, self.default_handler.__name__,
                  getattr(obj, name))
Example #19
0
def test_create_bound_method():
    class X(object):
        pass
    def f(self):
        return self
    x = X()
    b = six.create_bound_method(f, x)
    assert isinstance(b, types.MethodType)
    assert b() is x
Example #20
0
def test_create_bound_method():
    class X(object):
        pass
    def f(self):
        return self
    x = X()
    b = six.create_bound_method(f, x)
    assert isinstance(b, types.MethodType)
    assert b() is x
Example #21
0
def register_extension_method(ext, base, *args, **kwargs):
    """Register the given extension method as a public attribute of the given base.

    README: The expected protocol here is that the given extension method is an unbound function.
    It will be bound to the specified base as a method, and then set as a public attribute of that
    base.
    """
    bound_method = create_bound_method(ext.plugin, base)
    setattr(base, ext.name.lstrip('_'), bound_method)
Example #22
0
def to_graph(func, recursive=True):
  new_func = tf.autograph.to_graph(
      func,
      recursive=recursive,
      experimental_optional_features=tf.autograph.experimental.Feature.ALL)
  # TODO(b/127686409): Remove this.
  if inspect.ismethod(func):
    return six.create_bound_method(new_func, func.__self__)
  return new_func
Example #23
0
def register_extension_method(ext, base, *args, **kwargs):
    """Register the given extension method as a public attribute of the given base.

    README: The expected protocol here is that the given extension method is an unbound function.
    It will be bound to the specified base as a method, and then set as a public attribute of that
    base.
    """
    bound_method = create_bound_method(ext.plugin, base)
    setattr(base, ext.name.lstrip('_'), bound_method)
Example #24
0
    def createResource(self, name, lockType):
        s = six.StringIO("%s:%s" % (name, lockType))
        s.seek(0)

        def close(self):
            raise Exception("I NEVER CLOSE!!!")

        s.close = six.create_bound_method(close, s)
        return s
Example #25
0
def client(app):
    client = app.test_client()

    def get_session_cookie(self, path="/"):
        return self.cookie_jar._cookies["localhost.local"][path]["session"]

    client.get_session_cookie = six.create_bound_method(
        get_session_cookie, client)

    yield client
Example #26
0
def _set_method(target, name, method):
    """ Set a mocked method onto the target.

    Target may be either an instance of a Session object of the
    requests.Session class. First we Bind the method if it's an instance.
    """
    if not isinstance(target, type):
        method = six.create_bound_method(method, target)

    setattr(target, name, method)
Example #27
0
 def __get__(self, instance, owner):
     if inspect.ismethoddescriptor(self.value) or inspect.isdatadescriptor(self.value):
         return self.value.__get__(instance, owner)
     if inspect.isfunction(self.value):
         if instance is None:
             return self
         else:
             return six.create_bound_method(self.value, instance)
     else:
         return self.value            
Example #28
0
    def _init_pyhooks(self):
        hooks = log.PyHooks.get('DFT', None)
        if hooks is None:
            return

        for label, hook in hooks.items():
            name   = "{}_hook".format(label)
            _hook = six.get_method_function(hook) if six.get_method_self(hook) else hook
            method = six.create_bound_method(_hook, DFT)
            setattr(self, name, method)
Example #29
0
def client(app):
    client = app.test_client()

    def get_session_cookie(self):
        return self.cookie_jar._cookies['localhost.local']['/']['session']

    client.get_session_cookie = six.create_bound_method(
        get_session_cookie, client,
    )

    return client
Example #30
0
def client(app):
    client = app.test_client()

    def get_session_cookie(self, path='/'):
        return self.cookie_jar._cookies['localhost.local'][path]['session']

    client.get_session_cookie = six.create_bound_method(
        get_session_cookie, client,
    )

    return client
Example #31
0
    def test_autospec_on_bound_builtin_function(self):
        meth = six.create_bound_method(time.ctime, time.time())
        self.assertIsInstance(meth(), str)
        mocked = create_autospec(meth)

        # no signature, so no spec to check against
        mocked()
        mocked.assert_called_once_with()
        mocked.reset_mock()
        mocked(4, 5, 6)
        mocked.assert_called_once_with(4, 5, 6)
Example #32
0
 def _create_action_method(self, i, action):
     # PP saving style action. No return value, e.g. "pp.lbft = 3".
     ns = locals().copy()
     exec(
         compile('def _f(self, field, f, pp, grib, cm): %s' % (action, ),
                 '<string>', 'exec'), globals(), ns)
     # Make it a method of ours.
     method = six.create_bound_method(ns['_f'], self)
     setattr(self, '_exec_action_%d' % (i, ), method)
     # Add to our list of actions.
     self._exec_actions.append(method)
Example #33
0
    def test_autospec_on_bound_builtin_function(self):
        meth = six.create_bound_method(time.ctime, time.time())
        self.assertIsInstance(meth(), str)
        mocked = create_autospec(meth)

        # no signature, so no spec to check against
        mocked()
        mocked.assert_called_once_with()
        mocked.reset_mock()
        mocked(4, 5, 6)
        mocked.assert_called_once_with(4, 5, 6)
Example #34
0
def getLogger(name):
    """Create logger with custom exception() method
    """
    def exception(self, msg, *args, **kwargs):
        extra = kwargs.setdefault('extra', {})
        extra['exc_fullstack'] = self.isEnabledFor(logging.DEBUG)
        kwargs['exc_info'] = True
        self.log(logging.ERROR, msg, *args, **kwargs)

    logger = logging.getLogger(name)
    logger.exception = six.create_bound_method(exception, logger)
    return logger
Example #35
0
def add_context_manager_support(obj):
    """ Add empty __enter__ and __exit__ methods on a given object.

    This function is required to be called on any object used by the data()
    methods on the stores. They are supposed to be file-like byte streams.
    Adding the support for using them as context managers allows us to make
    sure we clean the resources when a proper __exit__ method is available.

    """
    def __enter__(self):
        return self

    def __exit__(self, *args):
        pass

    if not hasattr(obj, '__enter__'):
        obj.__enter__ = create_bound_method(__enter__, obj)
    if not hasattr(obj, '__exit__'):
        obj.__exit__ = create_bound_method(__exit__, obj)

    return obj
Example #36
0
 def _create_action_method(self, i, action):
     # CM loading style action. Returns an object, such as a coord.
     ns = locals().copy()
     exec(
         compile(
             'def _f(self, field, f, pp, grib, cm): return %s' % (action, ),
             '<string>', 'exec'), globals(), ns)
     # Make it a method of ours.
     method = six.create_bound_method(ns['_f'], self)
     setattr(self, '_exec_action_%d' % (i, ), method)
     # Add to our list of actions.
     self._exec_actions.append(method)
Example #37
0
    def session_maker(*args, **kwargs):
        session = sessionmaker(*args, **kwargs)
        # XXX in case we want to use session manager somehow bound
        #     to request environment. For example, to generate user-specific
        #     URLs.
        #session.file_manager = \
        #        kwargs.get('file_manager', file_manager)
        session.file_manager = file_manager
        session.find_file_manager = six.create_bound_method(
            find_file_manager, session)

        return session
Example #38
0
    def __getattr__(self, name):
        """Look up and return attributes that are not defined on this instance.

        This function is called when code tries to read from an attribute that
        is not defined in this instance's __dict__. This function looks up
        the attribute on self.lib, and adds a variety of prefixes to the
        attribute name if necessary. If the attribute is not found on self.lib,
        an AttributeError is raised; if it is found, it is returned. However,
        if the attribute is callable, the attribute is first bound to this
        instance as a method.

        :param name: the name of the attribute to find
        :raises AttributeError: if the attribute (possibly with prefixes)
        is not found on self.lib
        """
        fun = None
        if re.match("__.*__", name):
            # This is a python internal name, skip it
            raise AttributeError
        if name == "lib":
            # If "lib" is not defined in self.__dict__, this function would
            # enter an infinite recursion if it tried to access self.lib.
            raise AttributeError

        # try it bare
        llib = self.lib
        try:
            fun = getattr(llib, name)
        except AttributeError:
            for prefix in self.prefixes:
                try:
                    # wrap it
                    fun = getattr(llib, prefix + name)
                    break
                except AttributeError:
                    pass
        if fun is None:
            # Return a proxy class to generate a good error on call
            error_printer = ErrorPrinter(name, self.prefixes)
            setattr(self, name, error_printer)
            return error_printer

        if not callable(fun):  # pragma: no cover
            setattr(self, name, fun)
            return fun

        new_fun = self.check_wrap(fun, name)
        new_method = six.create_bound_method(new_fun, weakref.proxy(self))

        # Store the wrapper function into the instance
        # to prevent a second lookup
        setattr(self, name, new_method)
        return new_method
Example #39
0
 def _create_conditions_method(self):
     # Bundle all the conditions into one big string.
     conditions = '(%s)' % ') and ('.join(self._conditions)
     if not conditions:
         conditions = 'None'
     # Create a method to evaluate the conditions.
     # NB. This creates the name '_f' in the 'ns' namespace, which is then
     # used below.
     code = 'def _f(self, field, f, pp, grib, cm): return %s' % conditions
     ns = locals().copy()
     exec(compile(code, '<string>', 'exec'), globals(), ns)
     # Make it a method of ours.
     self._exec_conditions = six.create_bound_method(ns['_f'], self)
Example #40
0
    def __get__(self, instance, owner):
        assert issubclass(owner,
                          Stub), 'stubbed methods belong in Stub classes...'
        assert instance, 'implemented for instance methods only'
        real_method = getattr(owner.stubbed, self.stub.__name__)
        assert isinstance(
            real_method.im_func,
            types.FunctionType), 'stubbed methods are for methods...'
        real_args = inspect.getargspec(real_method.im_func)
        stub_args = inspect.getargspec(self.stub)
        assert real_args == stub_args, 'argument specification mismatch'

        return six.create_bound_method(self.stub, instance)
Example #41
0
    def session_maker(*args, **kwargs):
        session = sessionmaker(*args, **kwargs)
        # XXX in case we want to use session manager somehow bound 
        #     to request environment. For example, to generate user-specific
        #     URLs.
        #session.file_manager = \
        #        kwargs.get('file_manager', file_manager)
        session.file_manager = file_manager
        session.find_file_manager = six.create_bound_method(
                                            find_file_manager,
                                            session)

        return session
Example #42
0
 def _create_conditions_method(self):
     # Bundle all the conditions into one big string.
     conditions = '(%s)' % ') and ('.join(self._conditions)
     if not conditions:
         conditions = 'None'
     # Create a method to evaluate the conditions.
     # NB. This creates the name '_f' in the 'ns' namespace, which is then
     # used below.
     code = 'def _f(self, field, f, pp, grib, cm): return %s' % conditions
     ns = locals().copy()
     exec(compile(code, '<string>', 'exec'), globals(), ns)
     # Make it a method of ours.
     self._exec_conditions = six.create_bound_method(ns['_f'], self)
Example #43
0
def add_context_manager_support(obj):
    """ Add empty __enter__ and __exit__ methods on a given object.

    This function is required to be called on any object used by the data()
    methods on the stores. They are supposed to be file-like byte streams.
    Adding the support for using them as context managers allows us to make
    sure we clean the resources when a proper __exit__ method is available.

    """

    def __enter__(self):
        return self

    def __exit__(self, *args):
        pass

    if not hasattr(obj, '__enter__'):
        obj.__enter__ = create_bound_method(__enter__, obj)
    if not hasattr(obj, '__exit__'):
        obj.__exit__ = create_bound_method(__exit__, obj)

    return obj
Example #44
0
File: rules.py Project: cdr30/iris
 def _create_action_method(self, i, action):
     # PP saving style action. No return value, e.g. "pp.lbft = 3".
     rules_globals = _rules_execution_environment()
     compile_locals = {}
     exec(
         compile('def _f(self, field, f, pp, grib, cm): %s' % (action, ),
                 '<string>', 'exec'), rules_globals, compile_locals)
     # Make it a method of ours.
     _f = compile_locals['_f']
     method = six.create_bound_method(_f, self)
     setattr(self, '_exec_action_%d' % (i, ), method)
     # Add to our list of actions.
     self._exec_actions.append(method)
Example #45
0
 def _create_action_method(self, i, action):
     # PP saving style action. No return value, e.g. "pp.lbft = 3".
     ns = locals().copy()
     exec(compile('def _f(self, field, f, pp, grib, cm): %s' % (action, ),
                  '<string>',
                  'exec'),
          globals(),
          ns)
     # Make it a method of ours.
     method = six.create_bound_method(ns['_f'], self)
     setattr(self, '_exec_action_%d' % (i, ), method)
     # Add to our list of actions.
     self._exec_actions.append(method)
Example #46
0
 def _create_action_method(self, i, action):
     # PP saving style action. No return value, e.g. "pp.lbft = 3".
     rules_globals = _rules_execution_environment()
     compile_locals = {}
     exec(compile('def _f(self, field, f, pp, grib, cm): %s' % (action, ),
                  '<string>',
                  'exec'),
          rules_globals, compile_locals)
     # Make it a method of ours.
     _f = compile_locals['_f']
     method = six.create_bound_method(_f, self)
     setattr(self, '_exec_action_%d' % (i, ), method)
     # Add to our list of actions.
     self._exec_actions.append(method)
Example #47
0
    def _give_columns_django_field_attributes(self):
        """
        Add Django Field attributes to each cqlengine.Column instance.

        So that the Django Options class may interact with it as if it were
        a Django Field.
        """
        methods_to_add = (
            django_field_methods.value_from_object,
            django_field_methods.value_to_string,
            django_field_methods.get_attname,
            django_field_methods.get_cache_name,
            django_field_methods.pre_save,
            django_field_methods.get_prep_value,
            django_field_methods.get_choices,
            django_field_methods.get_choices_default,
            django_field_methods.save_form_data,
            django_field_methods.formfield,
            django_field_methods.get_db_prep_value,
            django_field_methods.get_db_prep_save,
            django_field_methods.db_type_suffix,
            django_field_methods.select_format,
            django_field_methods.get_internal_type,
            django_field_methods.get_attname_column,
            django_field_methods.check,
            django_field_methods._check_field_name,
            django_field_methods._check_db_index,
            django_field_methods.deconstruct,
            django_field_methods.run_validators,
            django_field_methods.clean,
            django_field_methods.get_db_converters,
            django_field_methods.get_prep_lookup,
            django_field_methods.get_db_prep_lookup,
            django_field_methods.get_filter_kwargs_for_object,
            django_field_methods.set_attributes_from_name,
            django_field_methods.db_parameters,
            django_field_methods.get_pk_value_on_save,
            django_field_methods.get_col,
        )
        for name, cql_column in six.iteritems(self._defined_columns):
            self._set_column_django_attributes(cql_column=cql_column, name=name)
            for method in methods_to_add:
                try:
                    method_name = method.func_name
                except AttributeError:
                    # python 3
                    method_name = method.__name__

                new_method = six.create_bound_method(method, cql_column)
                setattr(cql_column, method_name, new_method)
Example #48
0
    def __call__(self):
        """ Return the original listener method, or None if it no longer exists.
        """
        obj = self.obj
        if obj is None:
            # Unbound method.
            return six.create_unbound_method(self.func, self.cls)
        else:
            objc = obj()
            if objc is None:
                # Bound method whose object has been garbage collected.
                return

            return six.create_bound_method(self.func, objc)
Example #49
0
 def _create_conditions_method(self):
     # Bundle all the conditions into one big string.
     conditions = '(%s)' % ') and ('.join(self._conditions)
     if not conditions:
         conditions = 'None'
     # Create a method to evaluate the conditions.
     # NB. This creates the name '_f' in the 'compile_locals' namespace,
     # which is then used below.
     code = 'def _f(self, field, f, pp, grib, cm): return %s' % conditions
     rules_globals = _rules_execution_environment()
     compile_locals = {}
     exec(compile(code, '<string>', 'exec'), rules_globals, compile_locals)
     # Make it a method of ours.
     _f = compile_locals['_f']
     self._exec_conditions = six.create_bound_method(_f, self)
Example #50
0
 def _create_action_method(self, i, action):
     # CM loading style action. Returns an object, such as a coord.
     ns = locals().copy()
     exec(
         compile(
             'def _f(self, field, f, pp, grib, cm): return %s' % (action, ),
             '<string>',
             'exec'),
         globals(),
         ns)
     # Make it a method of ours.
     method = six.create_bound_method(ns['_f'], self)
     setattr(self, '_exec_action_%d' % (i, ), method)
     # Add to our list of actions.
     self._exec_actions.append(method)
Example #51
0
File: rules.py Project: cdr30/iris
 def _create_action_method(self, i, action):
     # CM loading style action. Returns an object, such as a coord.
     # Compile a new method for the operation.
     rules_globals = _rules_execution_environment()
     compile_locals = {}
     exec(
         compile("def _f(self, field, f, pp, grib, cm): return %s" % (action,), "<string>", "exec"),
         rules_globals,
         compile_locals,
     )
     # Make it a method of ours.
     _f = compile_locals["_f"]
     method = six.create_bound_method(_f, self)
     setattr(self, "_exec_action_%d" % (i,), method)
     # Add to our list of actions.
     self._exec_actions.append(method)
Example #52
0
    def __init__(self, *args, **kwargs):
        """Inits the document with given data and validates the fields
        (field validation bad idea during init?). If you define
        ``__init__`` method for your document class, make sure to call
        this
        ::

            class MyDoc(BaseDocument, dot_notation=True):
                foo = Field(str)
                bar = Field(int, required=False)

                def __init__(self, *args, **kwargs):
                    super(MyDoc, self).__init__(*args, **kwargs)
                    # do other stuff
        """
        # if input dict, merge (not updating) into kwargs
        if args and not isinstance(args[0], dict):
            raise TypeError('dict or dict subclass argument expected')
        elif args:
            for field_name, field_value in args[0].items():
                if field_name not in kwargs:
                    kwargs[field_name] = field_value
        super(BaseDocument, self).__init__()
        for field_name, field in self.nanomongo.fields.items():
            if hasattr(field, 'default_value'):
                val = field.default_value
                dict.__setitem__(self, field_name, val() if callable(val) else val)
            # attach get_<field_name>_field methods for DBRef fields
            if field.data_type in [DBRef] + DBRef.__subclasses__():
                getter_name = 'get_%s_field' % field_name
                doc_class = field.document_class if hasattr(field, 'document_class') else None
                getter = ref_getter_maker(field_name, document_class=doc_class)
                setattr(self, getter_name, six.create_bound_method(getter, self))
        for field_name in kwargs:
            if self.nanomongo.has_field(field_name):
                self.nanomongo.validate(field_name, kwargs[field_name])
                dict.__setitem__(self, field_name, kwargs[field_name])
            else:
                raise ExtraFieldError('Undefined field %s=%s in %s' %
                                      (field_name, kwargs[field_name], self.__class__))
        for field_name, field_value in self.items():
            # transform dict to RecordingDict so we can track diff in embedded docs
            if isinstance(field_value, dict):
                dict.__setitem__(self, field_name, RecordingDict(field_value))
Example #53
0
    def test_365_calendar(self):
        f = mock.MagicMock(lbtim=SplittableInt(4, {'ia': 2, 'ib': 1, 'ic': 0}),
                           lbyr=2013, lbmon=1, lbdat=1, lbhr=12, lbmin=0,
                           lbsec=0,
                           t1=netcdftime.datetime(2013, 1, 1, 12, 0, 0),
                           t2=netcdftime.datetime(2013, 1, 2, 12, 0, 0),
                           spec=PPField3)
        f.time_unit = six.create_bound_method(PPField3.time_unit, f)
        f.calendar = cf_units.CALENDAR_365_DAY
        (factories, references, standard_name, long_name, units,
         attributes, cell_methods, dim_coords_and_dims,
         aux_coords_and_dims) = convert(f)

        def is_t_coord(coord_and_dims):
            coord, dims = coord_and_dims
            return coord.standard_name == 'time'

        coords_and_dims = list(filter(is_t_coord, aux_coords_and_dims))
        self.assertEqual(len(coords_and_dims), 1)
        coord, dims = coords_and_dims[0]
        self.assertEqual(guess_coord_axis(coord), 'T')
        self.assertEqual(coord.units.calendar, '365_day')
Example #54
0
    def __get__(self, obj, obj_type=None):
        """
            To allow each instance of a class to have different callbacks
        registered we store a callback registry on the instance itself.
        Keying off of the id of the decorator allows us to have multiple
        methods support callbacks on the same instance simultaneously.
        """
        # method is being called on the class instead of an instance
        if obj is None:
            # when target was decorated, it had not been bound yet, but now it
            # is, so update _target_is_method.
            self._target_is_method = True
            return self

        if (obj not in self._callback_registries):
            callback_registry = SupportsCallbacks(self,
                    target_is_method=True)
            self._callback_registries[obj] = proxy(callback_registry)
        else:
            callback_registry = self._callback_registries[obj]

        return six.create_bound_method(callback_registry, obj)
Example #55
0
def create_multi_node_evaluator(actual_evaluator, communicator):
    """Create a multi node evaluator from a normal evaluator.

    Actually this method patches the evaluator to work in multi node
    environment. This method adds several hidden attributes starting
    with `_mn_` prefix.

    Args:
        actual_evaluator: evaluator to be patched
            (e.g., ``chainer.training.extensions.Evaluator``)
        communicator: ChainerMN communicator

    Returns:
        The multi-node patched ``actual_evaluator``.

    .. note:: After patched, original evaluator does not work
              correctly in non-MPI environment.

    """

    actual_evaluator._mn_original_evaluate = actual_evaluator.evaluate
    actual_evaluator._mn_communicator = communicator

    def new_evaluate(self):
        local_mean_dict = self._mn_original_evaluate()
        global_mean_dict = {
            name:
            self._mn_communicator.allreduce_obj(
                value) / self._mn_communicator.size
            for name, value in sorted(local_mean_dict.items())
        }
        return global_mean_dict

    actual_evaluator.evaluate = six.create_bound_method(
        new_evaluate, actual_evaluator)
    return actual_evaluator
Example #56
0
    def addMethods(self, usePsyco=False):
        """Add Python-specific functions to this object's methods,
        accelerating them with psyco, if it is available."""

        # Add the auxiliary function specs to this Generator's namespace
        for auxfnname in self.funcspec._pyauxfns:
            fninfo = self.funcspec._pyauxfns[auxfnname]
            if not hasattr(self, fninfo[1]):
                # user-defined auxiliary functions
                # (built-ins are provided explicitly)
                try:
                    exec(fninfo[0])
                except:
                    print("Error in supplied auxiliary function code")
                self._funcreg[fninfo[1]] = ("self", fninfo[0])
                setattr(self, fninfo[1], six.create_bound_method(locals()[fninfo[1]], self))
                # user auxiliary function interface wrapper
                try:
                    uafi_code = self.funcspec._user_auxfn_interface[auxfnname]
                    try:
                        exec(uafi_code)
                    except:
                        print("Error in auxiliary function wrapper")
                        raise
                    setattr(self.auxfns, auxfnname, six.create_bound_method(locals()[auxfnname], self.auxfns))
                    self._funcreg[auxfnname] = ("", uafi_code)
                except KeyError:
                    # not a user-defined aux fn
                    pass
            # bind all the auxfns here
            if HAVE_PSYCO and usePsyco:
                psyco.bind(getattr(self, fninfo[1]))
                try:
                    psyco.bind(self.auxfns[auxfnname])
                except KeyError:
                    # not a user-defined aux fn
                    pass
        # Add the spec function to this Generator's namespace if
        # target language is python (otherwise integrator exposes it anyway)
        if self.funcspec.targetlang == "python":
            fninfo = self.funcspec.spec
            try:
                exec(fninfo[0])
            except:
                print("Error in supplied functional specification code")
                raise
            self._funcreg[fninfo[1]] = ("self", fninfo[0])
            setattr(self, fninfo[1], six.create_bound_method(locals()[fninfo[1]], self))
            if HAVE_PSYCO and usePsyco:
                psyco.bind(getattr(self, fninfo[1]))
            # Add the auxiliary spec function (if present) to this
            # Generator's namespace
            if self.funcspec.auxspec != "":
                fninfo = self.funcspec.auxspec
                try:
                    exec(fninfo[0])
                except:
                    print("Error in supplied auxiliary variable code")
                    raise
                self._funcreg[fninfo[1]] = ("self", fninfo[0])
                setattr(self, fninfo[1], six.create_bound_method(locals()[fninfo[1]], self))
                if HAVE_PSYCO and usePsyco:
                    psyco.bind(getattr(self, fninfo[1]))
Example #57
0
 def __get__(self, obj, owner):
     return type(self)(six.create_bound_method(self._should_ignore_ex, obj))
Example #58
0
    def _generate_operator_funcs(self, yaql_operators, engine):
        binary_doc = ''
        unary_doc = ''
        precedence_dict = {}

        for up, bp, op_name, op_alias in yaql_operators.operators.values():
            self._aliases[op_name] = op_alias
            if up:
                l = precedence_dict.setdefault(
                    (abs(up), 'l' if up > 0 else 'r'), [])
                l.append('UNARY_' + op_name if bp else op_name)
                unary_doc += ('value : ' if not unary_doc else '\n| ')
                spec_prefix = '{0} value' if up > 0 else 'value {0}'
                if bp:
                    unary_doc += (spec_prefix + ' %prec UNARY_{0}').format(
                        op_name)
                else:
                    unary_doc += spec_prefix.format(op_name)
            if bp:
                l = precedence_dict.setdefault(
                    (abs(bp), 'l' if bp > 0 else 'r'), [])
                l.append(op_name)
                binary_doc += ('value : ' if not binary_doc else '\n| ') + \
                    'value {0} value'.format(op_name)

        # noinspection PyProtectedMember
        def p_binary(this, p):
            alias = this._aliases.get(p.slice[2].type)
            p[0] = expressions.BinaryOperator(p[2], p[1], p[3], alias)

        # noinspection PyProtectedMember
        def p_unary(this, p):
            if p[1] in yaql_operators.operators:
                alias = this._aliases.get(p.slice[1].type)
                p[0] = expressions.UnaryOperator(p[1], p[2], alias)
            else:
                alias = this._aliases.get(p.slice[2].type)
                p[0] = expressions.UnaryOperator(p[2], p[1], alias)

        p_binary.__doc__ = binary_doc
        self.p_binary = six.create_bound_method(p_binary, self)
        p_unary.__doc__ = unary_doc
        self.p_unary = six.create_bound_method(p_unary, self)

        precedence = []
        for i in range(1, len(precedence_dict) + 1):
            for oa in ('r', 'l'):
                value = precedence_dict.get((i, oa))
                if value:
                    precedence.append(
                        (('left',) if oa is 'l' else ('right',)) +
                        tuple(value)
                    )
        precedence.insert(1, ('left', 'LIST', 'INDEXER', 'MAP'))
        precedence.insert(0, ('left', 'MAPPING'))
        precedence.insert(0, ('left', ','))
        precedence.reverse()
        self.precedence = tuple(precedence)

        def p_value_call(this, p):
            """
            func : value '(' args ')'
            """
            arg = ()
            if len(p) > 4:
                arg = p[3]
            p[0] = expressions.Function('#call', p[1], *arg)

        if engine.allow_delegates:
            self.p_value_call = six.create_bound_method(p_value_call, self)