def __reduce__(self):
r"""
EXAMPLES::
sage: w = Word(lambda n : n%3+10, caching=True)
sage: w.__reduce__()
(Words, ("csage.misc.fpickle...<lambda>...", +Infinity, 'pickled_function', True))
::
sage: w = Word(lambda n : n%3+10, caching=True, length=8)
sage: w.__reduce__()
(Words, ("csage.misc.fpickle...<lambda>...", 8, 'pickled_function', True))
Because ``pickle_function`` fails on CallableFromListOfWords,
then concatenation of words are expanded as a list::
sage: w = Word(range(5)) + Word('abcde')
sage: w.__reduce__()
(Words, ([0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e'],))
"""
from sage.misc.fpickle import pickle_function
try:
s = pickle_function(self._func)
except Exception:
from sage.combinat.words.word import FiniteWord_class
if isinstance(self, FiniteWord_class):
return self._parent, (list(self), )
else:
return self._parent, (self._func, self._len, 'callable', True)
else:
return self._parent, (s, self._len, 'pickled_function', True)
def __reduce__(self):
r"""
EXAMPLES::
sage: w = Word(lambda n : n%3+10, caching=False)
sage: w.__reduce__()
(Infinite words over Set of Python objects of class 'object',
(...csage.misc.fpickle...<lambda>..., 'pickled_function', False))
::
sage: w = Word(lambda n : n%3+10, caching=False, length=8)
sage: w.__reduce__()
(Finite words over Set of Python objects of class 'object',
(...csage.misc.fpickle...<lambda>..., 8, 'pickled_function', False))
"""
from sage.misc.fpickle import pickle_function
try:
s = pickle_function(self._func)
except Exception:
if self.is_finite():
return self._parent, (list(self), )
else:
return self._parent, (self._func, 'callable', False)
else:
if self.is_finite():
return self._parent, (s, self._len, 'pickled_function', False)
else:
return self._parent, (s, 'pickled_function', False)
def __getstate__(self):
"""
EXAMPLES::
sage: from sage.sets.family import LazyFamily
sage: f = LazyFamily([3,4,7], lambda i: 2*i)
sage: d = f.__getstate__()
sage: d['set']
[3, 4, 7]
sage: f = LazyFamily(Permutations(3), lambda p: p.to_lehmer_code())
sage: f == loads(dumps(f))
True
sage: f = LazyFamily(Permutations(3), attrcall("to_lehmer_code"))
sage: f == loads(dumps(f))
True
"""
f = self.function
# This should be done once for all by registering
# sage.misc.fpickle.pickle_function to copy_reg
if type(f) is type(
Family): # TODO: where is the python `function` type?
from sage.misc.fpickle import pickle_function
f = pickle_function(f)
return {'set': self.set, 'function': f}
def __reduce__(self):
r"""
EXAMPLES::
sage: w = Word(lambda n : n%3+10, caching=False)
sage: w.__reduce__()
(Words, ("csage.misc.fpickle...<lambda>...", +Infinity, 'pickled_function', False))
::
sage: w = Word(lambda n : n%3+10, caching=False, length=8)
sage: w.__reduce__()
(Words, ("csage.misc.fpickle...<lambda>...", 8, 'pickled_function', False))
"""
from sage.misc.fpickle import pickle_function
try:
s = pickle_function(self._func)
except Exception:
from sage.combinat.words.word import FiniteWord_class
if isinstance(self, FiniteWord_class):
return self._parent, (list(self), )
else:
return self._parent, (self._func, self._len, 'callable', False)
else:
return self._parent, (s, self._len, 'pickled_function', False)
def __getstate__(self):
"""
EXAMPLES::
sage: from sage.sets.family import LazyFamily
sage: f = LazyFamily([3,4,7], lambda i: 2*i)
sage: d = f.__getstate__()
sage: d['set']
[3, 4, 7]
sage: f = LazyFamily(Permutations(3), lambda p: p.to_lehmer_code())
sage: f == loads(dumps(f))
True
sage: f = LazyFamily(Permutations(3), attrcall("to_lehmer_code"))
sage: f == loads(dumps(f))
True
"""
f = self.function
# This should be done once for all by registering
# sage.misc.fpickle.pickle_function to copy_reg
if isinstance(f, type(Family)): # TODO: where is the python `function` type?
from sage.misc.fpickle import pickle_function
f = pickle_function(f)
return {'set': self.set,
'function': f}
def __reduce__(self):
r"""
EXAMPLES::
sage: w = Word(lambda n : n%3+10, caching=False)
sage: w.__reduce__()
(Words, ("csage.misc.fpickle...<lambda>...", +Infinity, 'pickled_function', False))
::
sage: w = Word(lambda n : n%3+10, caching=False, length=8)
sage: w.__reduce__()
(Words, ("csage.misc.fpickle...<lambda>...", 8, 'pickled_function', False))
"""
from sage.misc.fpickle import pickle_function
try:
s = pickle_function(self._func)
except Exception:
from sage.combinat.words.word import FiniteWord_class
if isinstance(self, FiniteWord_class):
return self._parent, (list(self),)
else:
return self._parent, (self._func, self._len, 'callable', False)
else:
return self._parent, (s, self._len, 'pickled_function', False)
def __reduce__(self):
r"""
EXAMPLES::
sage: w = Word(lambda n : n%3+10, caching=True)
sage: w.__reduce__()
(Words, ("csage.misc.fpickle...<lambda>...", +Infinity, 'pickled_function', True))
::
sage: w = Word(lambda n : n%3+10, caching=True, length=8)
sage: w.__reduce__()
(Words, ("csage.misc.fpickle...<lambda>...", 8, 'pickled_function', True))
Because ``pickle_function`` fails on CallableFromListOfWords,
then concatenation of words are expanded as a list::
sage: w = Word(range(5)) + Word('abcde')
sage: w.__reduce__()
(Words, ([0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e'],))
"""
from sage.misc.fpickle import pickle_function
try:
s = pickle_function(self._func)
except Exception:
from sage.combinat.words.word import FiniteWord_class
if isinstance(self, FiniteWord_class):
return self._parent, (list(self),)
else:
return self._parent, (self._func, self._len, 'callable', True)
else:
return self._parent, (s, self._len, 'pickled_function', True)
def parallel_iter(processes, f, inputs):
"""
Return a parallel iterator.
INPUT:
- ``processes`` -- integer
- ``f`` -- function
- ``inputs`` -- an iterable of pairs (args, kwds)
OUTPUT:
- iterator over values of ``f`` at ``args,kwds`` in some random order.
EXAMPLES::
sage: def f(x): return x+x
sage: import sage.parallel.multiprocessing_sage
sage: v = list(sage.parallel.multiprocessing_sage.parallel_iter(2, f, [((2,), {}), ((3,),{})]))
sage: v.sort(); v
[(((2,), {}), 4), (((3,), {}), 6)]
"""
from twisted.internet import reactor # do not delete this (!) -- see trac 8785
if processes == 0: processes = ncpus.ncpus()
p = Pool(processes)
fp = pickle_function(f)
result = p.imap_unordered(call_pickled_function, [(fp, t) for t in inputs])
for res in result:
yield res
p.close()
p.join()
def __reduce__(self):
r"""
EXAMPLES::
sage: w = Word(lambda n : n%3+10, caching=False)
sage: w.__reduce__()
(Infinite words over Set of Python objects of type 'object',
("csage.misc.fpickle...<lambda>...", 'pickled_function', False))
::
sage: w = Word(lambda n : n%3+10, caching=False, length=8)
sage: w.__reduce__()
(Finite words over Set of Python objects of type 'object',
("csage.misc.fpickle...<lambda>...", 8, 'pickled_function', False))
"""
from sage.misc.fpickle import pickle_function
try:
s = pickle_function(self._func)
except Exception:
if self.is_finite():
return self._parent, (list(self),)
else:
return self._parent, (self._func, 'callable', False)
else:
if self.is_finite():
return self._parent, (s, self._len, 'pickled_function', False)
else:
return self._parent, (s, 'pickled_function', False)
def parallel_iter(processes, f, inputs):
"""
Return a parallel iterator.
INPUT:
- ``processes`` -- integer
- ``f`` -- function
- ``inputs`` -- an iterable of pairs (args, kwds)
OUTPUT:
- iterator over values of ``f`` at ``args,kwds`` in some random order.
EXAMPLES::
sage: def f(x): return x+x
sage: import sage.parallel.multiprocessing_sage
sage: v = list(sage.parallel.multiprocessing_sage.parallel_iter(2, f, [((2,), {}), ((3,),{})]))
sage: v.sort(); v
[(((2,), {}), 4), (((3,), {}), 6)]
"""
from twisted.internet import reactor # do not delete this (!) -- see trac 8785
if processes == 0: processes = ncpus.ncpus()
p = Pool(processes)
fp = pickle_function(f)
result = p.imap_unordered(call_pickled_function, [ (fp, t) for t in inputs ])
for res in result:
yield res
p.close()
p.join()
def __getstate__(self):
"""
TESTS::
sage: f = Family([3,4,7], lambda i: 2*i, hidden_keys=[2])
sage: d = f.__getstate__()
sage: d['hidden_keys']
[2]
"""
from sage.misc.fpickle import pickle_function
f = pickle_function(self.hidden_function)
return {'dictionary': self._dictionary,
'hidden_keys': self._hidden_keys,
'hidden_dictionary': self.hidden_dictionary,
'hidden_function': f}
def __getstate__(self):
"""
TESTS::
sage: f = Family([3,4,7], lambda i: 2*i, hidden_keys=[2])
sage: d = f.__getstate__()
sage: d['hidden_keys']
[2]
"""
from sage.misc.fpickle import pickle_function
f = pickle_function(self.hidden_function)
return {'dictionary': self._dictionary,
'hidden_keys': self._hidden_keys,
'hidden_dictionary': self.hidden_dictionary,
'hidden_function': f}
def __reduce__(self):
"""
Pickling.
EXAMPLES::
sage: from sage.misc.lazy_string import lazy_string
sage: f = lambda: "laziness"
sage: s = lazy_string(f)
sage: TestSuite(s).run() # indirect doctest
"""
import types
if isinstance(self._func, types.FunctionType):
from sage.misc.fpickle import pickle_function
f = pickle_function(self._func)
ftype = 'func'
else:
f = self.func
ftype = None
return _make_lazy_string, (ftype, f, self._args, self._kwargs)
def __reduce__(self):
"""
Pickling.
EXAMPLES::
sage: from sage.misc.lazy_string import lazy_string
sage: f = lambda: "laziness"
sage: s = lazy_string(f)
sage: TestSuite(s).run() # indirect doctest
"""
import types
if isinstance(self._func, types.FunctionType):
from sage.misc.fpickle import pickle_function
f = pickle_function(self._func)
ftype = 'func'
else:
f = self.func
ftype = None
return _make_lazy_string, (ftype, f, self._args, self._kwargs)
def __reduce__(self):
r"""
EXAMPLES::
sage: w = Word(lambda n : n%3+10, caching=True)
sage: w.__reduce__()
(Infinite words over Set of Python objects of type 'object',
("csage.misc.fpickle...<lambda>...", 'pickled_function', True))
::
sage: w = Word(lambda n : n%3+10, caching=True, length=8)
sage: w.__reduce__()
(Finite words over Set of Python objects of type 'object',
("csage.misc.fpickle...<lambda>...", 8, 'pickled_function', True))
Because ``pickle_function`` fails on CallableFromListOfWords,
then concatenation of words are expanded as a list::
sage: w = Word(range(5)) + Word('abcde')
sage: w.__reduce__()
(Finite words over Set of Python objects of type 'object', ([0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e'],))
"""
from sage.misc.fpickle import pickle_function
try:
s = pickle_function(self._func)
except Exception:
if self.is_finite():
return self._parent, (list(self),)
else:
return self._parent, (self._func, "callable", True)
else:
if self.is_finite():
return self._parent, (s, self._len, "pickled_function", True)
else:
return self._parent, (s, "pickled_function", True)
def __reduce__(self):
r"""
EXAMPLES::
sage: w = Word(lambda n : n%3+10, caching=True)
sage: w.__reduce__()
(Infinite words over Set of Python objects of class 'object',
(...csage.misc.fpickle...<lambda>..., 'pickled_function', True))
::
sage: w = Word(lambda n : n%3+10, caching=True, length=8)
sage: w.__reduce__()
(Finite words over Set of Python objects of class 'object',
(...csage.misc.fpickle...<lambda>..., 8, 'pickled_function', True))
Because ``pickle_function`` fails on CallableFromListOfWords,
then concatenation of words are expanded as a list::
sage: w = Word(range(5)) + Word('abcde')
sage: w.__reduce__()
(Finite words over Set of Python objects of class 'object', ([0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e'],))
"""
from sage.misc.fpickle import pickle_function
try:
s = pickle_function(self._func)
except Exception:
if self.is_finite():
return self._parent, (list(self), )
else:
return self._parent, (self._func, 'callable', True)
else:
if self.is_finite():
return self._parent, (s, self._len, 'pickled_function', True)
else:
return self._parent, (s, 'pickled_function', True)
