Пример #1
0
def test_array_subclass():
    try:
        import numpy as np

        class TestArray(np.ndarray):
            def __new__(cls, input_array, color):
                obj = np.asarray(input_array).view(cls)
                obj.color = color
                return obj
            def __array_finalize__(self, obj):
                if obj is None:
                    return
                if isinstance(obj, type(self)):
                    self.color = obj.color
            def __getnewargs__(self):
                return np.asarray(self), self.color

        a1 = TestArray(np.zeros(100), color='green')
        assert dill.pickles(a1)
        assert a1.__dict__ == dill.copy(a1).__dict__

        a2 = a1[0:9]
        assert dill.pickles(a2)
        assert a2.__dict__ == dill.copy(a2).__dict__

        class TestArray2(np.ndarray):
            color = 'blue'

        a3 = TestArray2([1,2,3,4,5])
        a3.color = 'green'
        assert dill.pickles(a3)
        assert a3.__dict__ == dill.copy(a3).__dict__

    except ImportError: pass
Пример #2
0
 def __deepcopy__(self, memo):
     import copy
     import dill
     cls = self.__class__
     result = cls.__new__(cls)
     memo[id(self)] = result
     for k, v in self.__dict__.items():
         if v is self._cost:
             setattr(result, k, tuple(dill.copy(i) for i in v))
         else:
             try: #XXX: work-around instancemethods in python2.6
                 setattr(result, k, copy.deepcopy(v, memo))
             except TypeError:
                 setattr(result, k, dill.copy(v))
     return result
Пример #3
0
def errors(obj, depth=0, exact=False, safe=False):
    """get errors for objects that fail to pickle"""
    from dill import pickles, copy
    if not depth:
        try:
            pik = copy(obj)
            if exact:
                assert pik == obj, \
                    "Unpickling produces %s instead of %s" % (pik,obj)
            assert type(pik) == type(obj), \
                "Unpickling produces %s instead of %s" % (type(pik),type(obj))
            return None
        except Exception:
            import sys
            return sys.exc_info()[1]
    _dict = {}
    for attr in dir(obj):
        try:
            _attr = getattr(obj,attr)
        except Exception:
            import sys
            _dict[attr] = sys.exc_info()[1]
            continue
        if not pickles(_attr,exact,safe):
            _dict[attr] = errors(_attr,depth-1,exact,safe)
    return _dict
Пример #4
0
def test_data_unchanged():
    FooS = dill.copy(Foo)
    try:
        res = FooS().data
    except Exception:
        e = sys.exc_info()[1]
        raise AssertionError(str(e))
    else:
        assert res == 1
Пример #5
0
def test_super():
    assert dill.copy(obj1(), byref=True)
    assert dill.copy(obj1(), byref=True, recurse=True)
   #assert dill.copy(obj1(), recurse=True) #FIXME: fails __main__.py
    assert dill.copy(obj1())

    assert dill.copy(obj2(), byref=True)
    assert dill.copy(obj2(), byref=True, recurse=True)
   #assert dill.copy(obj2(), recurse=True) #FIXME: fails __main__.py
    assert dill.copy(obj2())

    assert dill.copy(obj3(), byref=True)
    assert dill.copy(obj3(), byref=True, recurse=True)
   #assert dill.copy(obj3(), recurse=True) #FIXME: fails __main__.py
    assert dill.copy(obj3())
Пример #6
0
def test_mixins():
    # test mixins
    assert double_add(1, 2, 3) == 2 * fx
    double_add.invert()
    assert double_add(1, 2, 3) == -2 * fx

    _d = dill.copy(double_add)
    assert _d(1, 2, 3) == -2 * fx
    _d.invert()
    assert _d(1, 2, 3) == 2 * fx

    assert _d.__wrapped__(1, 2, 3) == fx

    # XXX: issue or feature? in python3.4, inverted is linked through copy
    if not double_add.inverted[0]:
        double_add.invert()

    # test some stuff from source and pointers
    ds = dill.source
    dd = dill.detect
    assert ds.getsource(dd.freevars(quadish)["f"]) == "@quad_factory(a=0,b=4,c=0)\ndef quadish(x):\n  return x+1\n"
    assert ds.getsource(dd.freevars(quadruple)["f"]) == "@doubler\ndef quadruple(x):\n  return 2*x\n"
    assert ds.importable(quadish, source=False) == "from %s import quadish\n" % __name__
    assert ds.importable(quadruple, source=False) == "from %s import quadruple\n" % __name__
    assert ds.importable(quadratic, source=False) == "from %s import quadratic\n" % __name__
    assert ds.importable(double_add, source=False) == "from %s import double_add\n" % __name__
    assert (
        ds.importable(quadruple, source=True)
        == "def doubler(f):\n  def inner(*args, **kwds):\n    fx = f(*args, **kwds)\n    return 2*fx\n  return inner\n\n@doubler\ndef quadruple(x):\n  return 2*x\n"
    )
    # ***** #FIXME: this needs work
    result = ds.importable(quadish, source=True)
    a, b, c, _, result = result.split("\n", 4)
    assert (
        result
        == "def quad_factory(a=1,b=1,c=0):\n  def dec(f):\n    def func(*args,**kwds):\n      fx = f(*args,**kwds)\n      return a*fx**2 + b*fx + c\n    return func\n  return dec\n\n@quad_factory(a=0,b=4,c=0)\ndef quadish(x):\n  return x+1\n"
    )
    assert set([a, b, c]) == set(["a = 0", "c = 0", "b = 4"])
    result = ds.importable(quadratic, source=True)
    a, b, c, result = result.split("\n", 3)
    assert (
        result
        == "\ndef dec(f):\n  def func(*args,**kwds):\n    fx = f(*args,**kwds)\n    return a*fx**2 + b*fx + c\n  return func\n"
    )
    assert set([a, b, c]) == set(["a = 1", "c = 0", "b = 1"])
    result = ds.importable(double_add, source=True)
    a, b, c, d, _, result = result.split("\n", 5)
    assert (
        result
        == "def quad(a=1, b=1, c=0):\n  inverted = [False]\n  def invert():\n    inverted[0] = not inverted[0]\n  def dec(f):\n    def func(*args, **kwds):\n      x = f(*args, **kwds)\n      if inverted[0]: x = -x\n      return a*x**2 + b*x + c\n    func.__wrapped__ = f\n    func.invert = invert\n    func.inverted = inverted\n    return func\n  return dec\n\n@quad(a=0,b=2)\ndef double_add(*args):\n  return sum(args)\n"
    )
    assert set([a, b, c, d]) == set(["a = 0", "c = 0", "b = 2", "inverted = [True]"])
Пример #7
0
def errors(obj, depth=0, exact=False):
    """get errors for objects that fail to pickle"""
    from dill import pickles, copy
    if not depth:
        try:
            pik = copy(obj)
            if exact:
                assert pik == obj, \
                    "Unpickling produces %s instead of %s" % (pik,obj)
            assert type(pik) == type(obj), \
                "Unpickling produces %s instead of %s" % (type(pik),type(obj))
            return None
        except Exception, err:
            return err
Пример #8
0
def errors(obj, depth=0, exact=False):
    """get errors for objects that fail to pickle"""
    from dill import pickles, copy
    if not depth:
        try:
            pik = copy(obj)
            if exact:
                assert pik == obj, \
                    "Unpickling produces %s instead of %s" % (pik,obj)
            assert type(pik) == type(obj), \
                "Unpickling produces %s instead of %s" % (type(pik),type(obj))
            return None
        except Exception:
            import sys
            return sys.exc_info()[1]
    return dict(((attr, errors(getattr(obj,attr),depth-1,exact=exact)) \
           for attr in dir(obj) if not pickles(getattr(obj,attr),exact)))
    def __init__(self, num_procs, controller_params, description):
        """
        Initialization routine for PFASST controller

        Args:
            num_procs: number of parallel time steps (still serial, though), can be 1
            controller_params: parameter set for the controller and the step class
            description: all the parameters to set up the rest (levels, problems, transfer, ...)
        """

        # call parent's initialization routine
        super(allinclusive_classic_nonMPI, self).__init__(controller_params)

        self.logger.warning('classic controller is about to become deprecated, use multigrid controller instead')

        self.MS = [stepclass.step(description)]

        # try to initialize via dill.copy (much faster for many time-steps)
        try:
            for p in range(num_procs - 1):
                self.MS.append(dill.copy(self.MS[0]))
        # if this fails (e.g. due to un-picklable data in the steps), initialize seperately
        except dill.PicklingError and TypeError:
            self.logger.warning('Need to initialize steps separately due to pickling error')
            for p in range(num_procs - 1):
                self.MS.append(stepclass.step(description))

        assert not (len(self.MS) > 1 and len(self.MS[0].levels) == 1), "ERROR: classic cannot do MSSDC"

        if self.params.dump_setup:
            self.dump_setup(step=self.MS[0], controller_params=controller_params, description=description)

        num_levels = len(self.MS[0].levels)

        if num_procs > 1 and num_levels > 1:
            for S in self.MS:
                for L in S.levels:
                    if not L.sweep.coll.right_is_node or L.sweep.params.do_coll_update:
                        raise ControllerError("For PFASST to work, we assume uend^k = u_M^k in this controller")

        for nl in range(len(self.MS[0].levels)):
            if self.MS[0].levels[nl].params.nsweeps > 1:
                raise ControllerError('classic controller cannot do multiple sweeps')
    def __init__(self, num_procs, controller_params, description):
        """
       Initialization routine for PFASST controller

       Args:
           num_procs: number of parallel time steps (still serial, though), can be 1
           controller_params: parameter set for the controller and the steps
           description: all the parameters to set up the rest (levels, problems, transfer, ...)
       """

        # call parent's initialization routine
        super(allinclusive_multigrid_nonMPI, self).__init__(controller_params)

        self.MS = [stepclass.step(description)]
        for p in range(num_procs - 1):
            self.MS.append(dill.copy(self.MS[0]))

        if self.params.dump_setup:
            self.dump_setup(step=self.MS[0], controller_params=controller_params, description=description)

        if num_procs > 1 and len(self.MS[0].levels) > 1:
            for S in self.MS:
                for L in S.levels:
                    if not L.sweep.coll.right_is_node:
                        raise ControllerError("For PFASST to work, we assume uend^k = u_M^k")

        if all(len(S.levels) == len(self.MS[0].levels) for S in self.MS):
            self.nlevels = len(self.MS[0].levels)
        else:
            raise ControllerError('all steps need to have the same number of levels')

        if self.nlevels == 0:
            raise ControllerError('need at least one level')

        self.nsweeps = []
        for nl in range(self.nlevels):

            if all(S.levels[nl].params.nsweeps == self.MS[0].levels[nl].params.nsweeps for S in self.MS):
                self.nsweeps.append(self.MS[0].levels[nl].params.nsweeps)

        if self.nlevels > 1 and self.nsweeps[-1] > 1:
            raise ControllerError('this controller cannot do multiple sweeps on coarsest level')
Пример #11
0
def test_mixins():
  # test mixins
  assert double_add(1,2,3) == 2*fx
  double_add.invert()
  assert double_add(1,2,3) == -2*fx

  _d = dill.copy(double_add)
  assert _d(1,2,3) == -2*fx
 #_d.invert() #FIXME: fails seemingly randomly
 #assert _d(1,2,3) == 2*fx

  assert _d.__wrapped__(1,2,3) == fx

  # XXX: issue or feature? in python3.4, inverted is linked through copy
  if not double_add.inverted[0]:
      double_add.invert()

  # test some stuff from source and pointers
  ds = dill.source
  dd = dill.detect
  assert ds.getsource(dd.freevars(quadish)['f']) == '@quad_factory(a=0,b=4,c=0)\ndef quadish(x):\n  return x+1\n'
  assert ds.getsource(dd.freevars(quadruple)['f']) == '@doubler\ndef quadruple(x):\n  return 2*x\n'
  assert ds.importable(quadish, source=False) == 'from %s import quadish\n' % __name__
  assert ds.importable(quadruple, source=False) == 'from %s import quadruple\n' % __name__
  assert ds.importable(quadratic, source=False) == 'from %s import quadratic\n' % __name__
  assert ds.importable(double_add, source=False) == 'from %s import double_add\n' % __name__
  assert ds.importable(quadruple, source=True) == 'def doubler(f):\n  def inner(*args, **kwds):\n    fx = f(*args, **kwds)\n    return 2*fx\n  return inner\n\n@doubler\ndef quadruple(x):\n  return 2*x\n'
  #***** #FIXME: this needs work
  result = ds.importable(quadish, source=True)
  a,b,c,_,result = result.split('\n',4)
  assert result == 'def quad_factory(a=1,b=1,c=0):\n  def dec(f):\n    def func(*args,**kwds):\n      fx = f(*args,**kwds)\n      return a*fx**2 + b*fx + c\n    return func\n  return dec\n\n@quad_factory(a=0,b=4,c=0)\ndef quadish(x):\n  return x+1\n'
  assert set([a,b,c]) == set(['a = 0', 'c = 0', 'b = 4'])
  result = ds.importable(quadratic, source=True)
  a,b,c,result = result.split('\n',3)
  assert result == '\ndef dec(f):\n  def func(*args,**kwds):\n    fx = f(*args,**kwds)\n    return a*fx**2 + b*fx + c\n  return func\n'
  assert set([a,b,c]) == set(['a = 1', 'c = 0', 'b = 1'])
  result = ds.importable(double_add, source=True)
  a,b,c,d,_,result = result.split('\n',5)
  assert result == 'def quad(a=1, b=1, c=0):\n  inverted = [False]\n  def invert():\n    inverted[0] = not inverted[0]\n  def dec(f):\n    def func(*args, **kwds):\n      x = f(*args, **kwds)\n      if inverted[0]: x = -x\n      return a*x**2 + b*x + c\n    func.__wrapped__ = f\n    func.invert = invert\n    func.inverted = inverted\n    return func\n  return dec\n\n@quad(a=0,b=2)\ndef double_add(*args):\n  return sum(args)\n'
  assert set([a,b,c,d]) == set(['a = 0', 'c = 0', 'b = 2', 'inverted = [True]'])
Пример #12
0
    def solve(self, steps):
        self.problem.eval_count = 0
        pool = pathos.pools.ProcessPool()
        n_cpus = pool.ncpus

        mapping_steps = int(steps**(1 / 5))
        self.steps_per_pool = steps // (n_cpus * mapping_steps)

        print(self.steps_per_pool)
        print(mapping_steps)
        print(n_cpus)

        to_solve = dill.copy(self)

        for i in range(mapping_steps):
            solutions = pool.map(self._solve_pool, [to_solve] * n_cpus)
            self.best_solution = max(
                (s for s in solutions + [self.best_solution]),
                key=lambda x: x.score)
            self.problem.eval_count += self.steps_per_pool * n_cpus
            self.record()
            print(i * n_cpus * self.steps_per_pool)
Пример #13
0
    return 2*fx
  return inner

@doubler
def quadruple(x):
  return 2*x


if __name__ == '__main__':

  # test mixins
  assert double_add(1,2,3) == 2*fx
  double_add.invert()
  assert double_add(1,2,3) == -2*fx

  _d = dill.copy(double_add)
  assert _d(1,2,3) == -2*fx
  _d.invert()
  assert _d(1,2,3) == 2*fx

  assert _d.__wrapped__(1,2,3) == fx

  # XXX: issue or feature? in python3.4, inverted is linked through copy
  if not double_add.inverted[0]:
      double_add.invert()

  # test some stuff from source and pointers
  ds = dill.source
  dd = dill.detect
  assert ds.getsource(dd.freevars(quadish)['f']) == '@quad_factory(a=0,b=4,c=0)\ndef quadish(x):\n  return x+1\n'
  assert ds.getsource(dd.freevars(quadruple)['f']) == '@doubler\ndef quadruple(x):\n  return 2*x\n'
Пример #14
0
def test_data_not_none():
    FooS = dill.copy(Foo)
    assert FooS.data.fget is not None
    assert FooS.data.fset is not None
    assert FooS.data.fdel is None
Пример #15
0
def test_super():
    assert dill.copy(obj1(), byref=True)
    assert dill.copy(obj1(), byref=True, recurse=True)
    assert dill.copy(obj1(), recurse=True)
    assert dill.copy(obj1())

    assert dill.copy(obj2(), byref=True)
    assert dill.copy(obj2(), byref=True, recurse=True)
    assert dill.copy(obj2(), recurse=True)
    assert dill.copy(obj2())

    assert dill.copy(obj3(), byref=True)
    assert dill.copy(obj3(), byref=True, recurse=True)
    assert dill.copy(obj3(), recurse=True)
    assert dill.copy(obj3())
Пример #16
0
    del sys.modules[module.__name__]
    del module

    module = dill.loads(pik_mod)
    assert hasattr(module, "a") and module.a == 1234
    assert module.double_add(1, 2, 3) == 2 * module.fx

except AttributeError:
    pass

# clean up
import os
os.remove(cached)
pycache = os.path.join(os.path.dirname(module.__file__), "__pycache__")
if os.path.exists(pycache) and not os.listdir(pycache):
    os.removedirs(pycache)


# test when module is None
import math

def get_lambda(str, **kwarg):
    return eval(str, kwarg, None)

obj = get_lambda('lambda x: math.exp(x)', math=math)
assert obj.__module__ is None
assert dill.copy(obj)(3) == obj(3)


# EOF
Пример #17
0
  def dec(f):
    def func(*args, **kwds):
      x = f(*args, **kwds)
      if inverted[0]: x = -x
      return a*x**2 + b*x + c
    func.__wrapped__ = f
    func.invert = invert
    return func
  return dec


@quad(a=0,b=2)
def double_add(*args):
  return sum(args)

fx = sum([1,2,3])

assert double_add(1,2,3) == 2*fx
double_add.invert()
assert double_add(1,2,3) == -2*fx

_d = dill.copy(double_add)
assert _d(1,2,3) == -2*fx
_d.invert()
assert _d(1,2,3) == 2*fx

assert _d.__wrapped__(1,2,3) == fx


# EOF
Пример #18
0
    class TestArray(np.ndarray):
        def __new__(cls, input_array, color):
            obj = np.asarray(input_array).view(cls)
            obj.color = color 
            return obj
        def __array_finalize__(self, obj):
            if obj is None:
                return
            if isinstance(obj, type(self)):
                self.color = obj.color
        def __getnewargs__(self):
            return np.asarray(self), self.color

    a1 = TestArray(np.zeros(100), color='green')
    assert dill.pickles(a1)
    assert a1.__dict__ == dill.copy(a1).__dict__

    a2 = a1[0:9]
    assert dill.pickles(a2)
    assert a2.__dict__ == dill.copy(a2).__dict__

    class TestArray2(np.ndarray):
        color = 'blue'

    a3 = TestArray2([1,2,3,4,5])
    a3.color = 'green'
    assert dill.pickles(a3)
    assert a3.__dict__ == dill.copy(a3).__dict__

except ImportError: pass
Пример #19
0
def test_partial():
    assert dill.copy(Machine(), byref=True)
    assert dill.copy(Machine(), byref=True, recurse=True)
    if not OLDER:
        assert dill.copy(Machine(), recurse=True)
    assert dill.copy(Machine())
Пример #20
0
def test_partials():
    assert dill.copy(SubMachine(), byref=True)
    assert dill.copy(SubMachine(), byref=True, recurse=True)
   #if not OLDER: #FIXME: fails __main__.py
   #    assert dill.copy(SubMachine(), recurse=True)
    assert dill.copy(SubMachine())
Пример #21
0
def test_data_not_none():
    FooS = dill.copy(Foo)
    assert FooS.data.fget is not None
    assert FooS.data.fset is not None
    assert FooS.data.fdel is None
#Lets print the best fit params
print("Loglik = %s" % fit.loglik)
fit.print_info()  #this is an obsolete function call, will be replaced!

# To get the phased signals:
for i in range(fit.npl):
    rv.phase_RV_planet_signal(fit, i + 1)

#################  Dynamical fitting #############################
# now lets fit dynamics model starting from the best Keplerian derived above

#first lets copy the Keplerian object, we will need it later for plotting
import dill

kep_fit = dill.copy(fit)

################# Plotting #############################

# lets make some basic plots with the "fit" object results:

import matplotlib.pyplot as plt
from matplotlib import gridspec
import matplotlib as mpl

import numpy as np

###### For nice plotting ##############

mpl.rcParams['axes.linewidth'] = 2.0  #set the value globally
mpl.rcParams['xtick.major.pad'] = '8'
Пример #23
0
def test_super():
    assert dill.copy(obj1(), byref=True)
    assert dill.copy(obj1(), byref=True, recurse=True)
    assert dill.copy(obj1(), recurse=True)
    assert dill.copy(obj1())

    assert dill.copy(obj2(), byref=True)
    assert dill.copy(obj2(), byref=True, recurse=True)
    assert dill.copy(obj2(), recurse=True)
    assert dill.copy(obj2())

    assert dill.copy(obj3(), byref=True)
    assert dill.copy(obj3(), byref=True, recurse=True)
    assert dill.copy(obj3(), recurse=True)
    assert dill.copy(obj3())
Пример #24
0
def test_slots():
    assert dill.pickles(Y)
    assert dill.pickles(y)
    assert dill.pickles(Y.y)
    assert dill.copy(y).y == value
Пример #25
0
    class TestArray(np.ndarray):
        def __new__(cls, input_array, color):
            obj = np.asarray(input_array).view(cls)
            obj.color = color 
            return obj
        def __array_finalize__(self, obj):
            if obj is None:
                return
            if isinstance(obj, type(self)):
                self.color = obj.color
        def __getnewargs__(self):
            return np.asarray(self), self.color

    a1 = TestArray(np.zeros(100), color='green')
    assert dill.pickles(a1)
    assert a1.__dict__ == dill.copy(a1).__dict__

    a2 = a1[0:9]
    assert dill.pickles(a2)
    assert a2.__dict__ == dill.copy(a2).__dict__

    class TestArray2(np.ndarray):
        color = 'blue'

    a3 = TestArray2([1,2,3,4,5])
    a3.color = 'green'
    assert dill.pickles(a3)
    assert a3.__dict__ == dill.copy(a3).__dict__

except ImportError: pass
Пример #26
0
            obj = np.asarray(input_array).view(cls)
            obj.color = color
            return obj

        def __array_finalize__(self, obj):
            if obj is None:
                return
            if isinstance(obj, type(self)):
                self.color = obj.color

        def __getnewargs__(self):
            return np.asarray(self), self.color

    a1 = TestArray(np.zeros(100), color='green')
    assert dill.pickles(a1)
    assert a1.__dict__ == dill.copy(a1).__dict__

    a2 = a1[0:9]
    assert dill.pickles(a2)
    assert a2.__dict__ == dill.copy(a2).__dict__

    class TestArray2(np.ndarray):
        color = 'blue'

    a3 = TestArray2([1, 2, 3, 4, 5])
    a3.color = 'green'
    assert dill.pickles(a3)
    assert a3.__dict__ == dill.copy(a3).__dict__

except ImportError:
    pass
Пример #27
0
    def __init__(self, num_procs, controller_params, description):
        """
        Initialization routine for PFASST controller

        Args:
           num_procs: number of parallel time steps (still serial, though), can be 1
           controller_params: parameter set for the controller and the steps
           description: all the parameters to set up the rest (levels, problems, transfer, ...)
        """

        if 'predict' in controller_params:
            raise ControllerError(
                'predict flag is ignored, use predict_type instead')

        # call parent's initialization routine
        super(controller_nonMPI, self).__init__(controller_params)

        self.MS = [stepclass.step(description)]

        # try to initialize via dill.copy (much faster for many time-steps)
        try:
            for p in range(num_procs - 1):
                self.MS.append(dill.copy(self.MS[0]))
        # if this fails (e.g. due to un-picklable data in the steps), initialize seperately
        except dill.PicklingError and TypeError:
            self.logger.warning(
                'Need to initialize steps separately due to pickling error')
            for p in range(num_procs - 1):
                self.MS.append(stepclass.step(description))

        if self.params.dump_setup:
            self.dump_setup(step=self.MS[0],
                            controller_params=controller_params,
                            description=description)

        if num_procs > 1 and len(self.MS[0].levels) > 1:
            for S in self.MS:
                for L in S.levels:
                    if not L.sweep.coll.right_is_node:
                        raise ControllerError(
                            "For PFASST to work, we assume uend^k = u_M^k")

        if all(len(S.levels) == len(self.MS[0].levels) for S in self.MS):
            self.nlevels = len(self.MS[0].levels)
        else:
            raise ControllerError(
                'all steps need to have the same number of levels')

        if self.nlevels == 0:
            raise ControllerError('need at least one level')

        self.nsweeps = []
        for nl in range(self.nlevels):

            if all(S.levels[nl].params.nsweeps ==
                   self.MS[0].levels[nl].params.nsweeps for S in self.MS):
                self.nsweeps.append(self.MS[0].levels[nl].params.nsweeps)

        if self.nlevels > 1 and self.nsweeps[-1] > 1:
            raise ControllerError(
                'this controller cannot do multiple sweeps on coarsest level')

        if self.nlevels == 1 and self.params.predict_type is not None:
            self.logger.warning(
                'you have specified a predictor type but only a single level.. '
                'predictor will be ignored')
Пример #28
0
def test_partial():
    assert dill.copy(Machine(), byref=True)
    assert dill.copy(Machine(), byref=True, recurse=True)
    if not OLDER:
        assert dill.copy(Machine(), recurse=True)
    assert dill.copy(Machine())
Пример #29
0
    del sys.modules[module.__name__]
    del module

    module = dill.loads(pik_mod)
    assert hasattr(module, "a") and module.a == 1234
    assert module.double_add(1, 2, 3) == 2 * module.fx

except AttributeError:
    pass

# clean up
import os
os.remove(cached)
pycache = os.path.join(os.path.dirname(module.__file__), "__pycache__")
if os.path.exists(pycache) and not os.listdir(pycache):
    os.removedirs(pycache)

# test when module is None
import math


def get_lambda(str, **kwarg):
    return eval(str, kwarg, None)


obj = get_lambda('lambda x: math.exp(x)', math=math)
assert obj.__module__ is None
assert dill.copy(obj)(3) == obj(3)

# EOF
Пример #30
0
def test_partials():
    assert dill.copy(SubMachine(), byref=True)
    assert dill.copy(SubMachine(), byref=True, recurse=True)
    #if not OLDER: #FIXME: fails __main__.py
    #    assert dill.copy(SubMachine(), recurse=True)
    assert dill.copy(SubMachine())
Пример #31
0
def test_slots():
    assert dill.pickles(Y)
    assert dill.pickles(y)
    assert dill.pickles(Y.y)
    assert dill.copy(y).y == value
Пример #32
0
#lets print the best fit params  
print("Loglik = %s"%fit.loglik)
fit.print_info() #this is an obsolete function call, will be replaced!


 
 
 
#################  Dynamical fitting #############################
# now lets fit dynamics model starting from the best Keplerian derived above

#first lets copy the Keplerian object, we will need it later for plotting
import dill

kep_fit = dill.copy(fit)


fit.mod_dynamical=True

fit.fitting(outputfiles=[1,1,1], doGP=False,  minimize_fortran=True,  minimize_loglik=True, amoeba_starts=20, print_stat=False, eps=1000, dt=10, npoints=6000, model_max=0, model_min=0)

#lets print the best fit params  
print("Loglik = %s"%fit.loglik)
fit.print_info() #this is an obsolete function call, will be replaced!
 
 
 
 
#lets copy the fit object as dyn_fit, we will need it later for plotting 
dyn_fit = dill.copy(fit)
Пример #33
0
def test_module_is_none():
    assert obj.__module__ is None
    assert dill.copy(obj)(3) == obj(3)
Пример #34
0

class Foo(object):
    def __init__(self):
        self._data = 1

    def _get_data(self):
        return self._data

    def _set_data(self, x):
        self._data = x

    data = property(_get_data, _set_data)


FooS = dill.copy(Foo)

assert FooS.data.fget is not None
assert FooS.data.fset is not None
assert FooS.data.fdel is None

try:
    res = FooS().data
except Exception:
    e = sys.exc_info()[1]
    raise AssertionError(str(e))
else:
    assert res == 1

try:
    f = FooS()