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 __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)