def register_message_classes(): """ Registers all classes we'll be serializing with cerealizer. """ l = [ Card, Suit, TableState, TableListing, PotState, PotWinner, Currency, PlayerState, PostBlind, Call, Raise, Fold, Limit, FixedLimit, ] l.extend(ALL_EVENTS) for message_class in l: try: cerealizer.register(message_class) except ValueError: logger.debug("Class already registered w/ cerealizer: %s" % message_class)
def test_cycle2(self): class Obj11(object): pass cerealizer.register(Obj11) o = Obj11() o.o = o o2 = cerealizer.loads(cerealizer.dumps(o)) assert o2.o is o2
def test_setstate_hacked(self): class Sec4: pass cerealizer.register(Sec4) o = Sec4() Sec4.__setstate__ = lambda obj, state: self.fail() cerealizer.loads(cerealizer.dumps(o))
def test_getstate_hacked(self): class Sec5: pass cerealizer.register(Sec5) o = Sec5() Sec5.__getstate__ = lambda obj: self.fail() cerealizer.loads(cerealizer.dumps(o))
def test_new_hacked(self): class Sec6: pass cerealizer.register(Sec6) o = Sec6() Sec6.__new__ = lambda Class: self.fail() cerealizer.loads(cerealizer.dumps(o))
def test_obj_newstyle(self): class Obj2(object): def __init__(self): self.x = 1 self.name = "jiba" def __eq__(a, b): return (a.__class__ is b.__class__) and (a.__dict__ == b.__dict__) cerealizer.register(Obj2) self.loads_dumps_and_compare(Obj2())
def test_cycle2(self): class ObjEmpty(object): pass cerealizer.register(ObjEmpty) o = ObjEmpty() o.o = o o2 = cerealizer.loads(cerealizer.dumps(o)) assert o2.o is o2
def test_obj_oldstyle(self): class Obj1: def __init__(self): self.x = 1 self.name = "jiba" def __eq__(a, b): return (a.__class__ is b.__class__) and (a.__dict__ == b.__dict__) cerealizer.register(Obj1) self.loads_dumps_and_compare(Obj1())
def test_obj_initargs2(self): class Obj9(object): def __init__(self, x, name): self.x = x self.name = name def __getinitargs__(self): return self.x, self.name def __eq__(a, b): return (a.__class__ is b.__class__) and (a.x == b.x) and (a.name == b.name) cerealizer.register(Obj9) o = Obj9(45, u"uioef") self.loads_dumps_and_compare(o)
def test_obj_slot(self): class Obj7(object): __slots__ = ["x", "name"] def __init__(self): self.x = 11.1 self.name = "jiba" def __eq__(a, b): return (a.__class__ is b.__class__) and (a.x == b.x) and (a.name == b.name) cerealizer.register(Obj7) o = Obj7() self.loads_dumps_and_compare(o)
def test_obj_slot(self): class ObjSlot(object): __slots__ = ["x", "name"] def __init__(self): self.x = 11.1 self.name = "jiba" def __eq__(a, b): return (a.__class__ is b.__class__) and (a.x == b.x) and (a.name == b.name) cerealizer.register(ObjSlot) o = ObjSlot() self.loads_dumps_and_compare(o)
def test_obj_initargs1(self): class ObjInitargs: def __init__(self, x, name): self.x = x self.name = name def __getinitargs__(self): return self.x, self.name def __eq__(a, b): return (a.__class__ is b.__class__) and (a.x == b.x) and (a.name == b.name) cerealizer.register(ObjInitargs) o = ObjInitargs(45, u"uioef") self.loads_dumps_and_compare(o)
def test_register3(self): class Sec3: pass cerealizer.register(Sec3) class Sec3: pass self.assertRaises(ValueError, lambda: cerealizer.register(Sec3))
def test_obj_newargs1(self): class Obj10(object): def __new__(Class, x, name): self = object.__new__(Class) self.x = x self.name = name return self def __getnewargs__(self): return self.x, self.name def __eq__(a, b): return (a.__class__ is b.__class__) and (a.x == b.x) and (a.name == b.name) cerealizer.register(Obj10) o = Obj10(45, u"uioef") self.loads_dumps_and_compare(o)
def test_obj_newargs1(self): class ObjNewargs1(object): def __new__(Class, x, name): self = object.__new__(Class) self.x = x self.name = name return self def __getnewargs__(self): return self.x, self.name def __eq__(a, b): return (a.__class__ is b.__class__) and (a.x == b.x) and (a.name == b.name) cerealizer.register(ObjNewargs1) o = ObjNewargs1(45, u"uioef") self.loads_dumps_and_compare(o)
def test_obj_newargs2(self): class Obj12(object): def __new__(Class, x): self = object.__new__(Class) self.x = x return self def __getnewargs__(self): return (self.x,) def __eq__(a, b): return (a.__class__ is b.__class__) and (a.x == b.x) cerealizer.register(Obj12) o = Obj12(45) o2 = Obj12(o) self.loads_dumps_and_compare(o2)
def test_cycle3(self): class Parent: pass class Child: def __init__(self, parent): self.parent = parent def __getstate__(self): return (self.parent,) def __setstate__(self, state): self.parent = state[0] cerealizer.register(Parent) cerealizer.register(Child) p = Parent() p.c = Child(p) p2 = cerealizer.loads(cerealizer.dumps(p)) assert not p2.c.parent is None
def test_obj_newargs2(self): class ObjNewargs2(object): def __new__(Class, x): self = object.__new__(Class) self.x = x return self def __getnewargs__(self): return (self.x,) def __eq__(a, b): return (a.__class__ is b.__class__) and (a.x == b.x) cerealizer.register(ObjNewargs2) o = ObjNewargs2(45) o2 = ObjNewargs2(o) self.loads_dumps_and_compare(o2)
def test_obj_setstate_priority2(self): TUPLE = (1, 2, 3, (4, (5, 6, (7,)))) class Obj6(object): def __init__(self): self.x = 1 self.name = "jiba" self.list = TUPLE[:] def __eq__(a, b): return (a.__class__ is b.__class__) and (a.__dict__ == b.__dict__) def __setstate__(self, state): assert state["list"] == TUPLE # Test that list is initialized BEFORE the object self.__dict__ = state cerealizer.register(Obj6) self.loads_dumps_and_compare(Obj6())
def test_obj_setstate_priority1(self): LIST = [1, 2, 3] class Obj3(object): def __init__(self): self.x = 1 self.name = "jiba" self.list = LIST[:] def __eq__(a, b): return (a.__class__ is b.__class__) and (a.__dict__ == b.__dict__) def __setstate__(self, state): assert state["list"] == LIST # Test that list is initialized BEFORE the object self.__dict__ = state cerealizer.register(Obj3) self.loads_dumps_and_compare(Obj3())
def test_cycle3(self): class Parent: pass class Child: def __init__(self, parent): self.parent = parent def __getstate__(self): return (self.parent,) def __setstate__(self, state): self.parent = state[0] cerealizer.register(Parent) cerealizer.register(Child) p = Parent() p.c = Child(p) p2 = cerealizer.loads(cerealizer.dumps(p)) assert p2.c.parent is not None
def test_obj_getstate_setstate(self): STATE = (1, 2, "jiba") class Obj4(object): def __init__(self): self.x = 1 self.name = "jiba" def __eq__(a, b): return (a.__class__ is b.__class__) and (a.__dict__ == b.__dict__) def __getstate__(self): return STATE def __setstate__(self, state): assert state == STATE self.x = 1 self.name = "jiba" cerealizer.register(Obj4) self.loads_dumps_and_compare(Obj4())
def test_obj_new_and_init(self): nbs = [0, 0] class Obj5(object): def __new__(Class): nbs[0] += 1 return object.__new__(Class) def __init__(self): nbs[1] += 1 self.x = 1 self.name = "jiba" def __eq__(a, b): return (a.__class__ is b.__class__) and (a.__dict__ == b.__dict__) cerealizer.register(Obj5) o = Obj5() self.loads_dumps_and_compare(o) assert nbs == [2, 1]
def test_obj_setstate_priority1(self): LIST = [1, 2, 3] class ObjList(object): def __init__(self): self.x = 1 self.name = "jiba" self.list = LIST[:] def __eq__(a, b): return (a.__class__ is b.__class__) and (a.__dict__ == b.__dict__) def __setstate__(self, state): assert state["list"] == LIST # Test that list is initialized BEFORE the object self.__dict__ = state cerealizer.register(ObjList) self.loads_dumps_and_compare(ObjList())
def test_obj_setstate_priority2(self): TUPLE = (1, 2, 3, (4, (5, 6, (7,)))) class ObjTuple(object): def __init__(self): self.x = 1 self.name = "jiba" self.list = TUPLE[:] def __eq__(a, b): return (a.__class__ is b.__class__) and (a.__dict__ == b.__dict__) def __setstate__(self, state): assert state["list"] == TUPLE # Test that list is initialized BEFORE the object self.__dict__ = state cerealizer.register(ObjTuple) self.loads_dumps_and_compare(ObjTuple())
def test_obj_getstate_setstate(self): STATE = (1, 2, "jiba") class ObjState(object): def __init__(self): self.x = 1 self.name = "jiba" def __eq__(a, b): return (a.__class__ is b.__class__) and (a.__dict__ == b.__dict__) def __getstate__(self): return STATE def __setstate__(self, state): assert state == STATE self.x = 1 self.name = "jiba" cerealizer.register(ObjState) self.loads_dumps_and_compare(ObjState())
def test_obj_new_and_init(self): nbs = [0, 0] class ObjInitNew(object): def __new__(Class): nbs[0] += 1 return object.__new__(Class) def __init__(self): nbs[1] += 1 self.x = 1 self.name = "jiba" def __eq__(a, b): return (a.__class__ is b.__class__) and (a.__dict__ == b.__dict__) cerealizer.register(ObjInitNew) o = ObjInitNew() self.loads_dumps_and_compare(o) assert nbs == [2, 1]
def Start(): Plugin.AddViewGroup("List", viewMode="List", mediaType="items") Plugin.AddViewGroup("InfoList", viewMode="InfoList", mediaType="items") ObjectContainer.title1 = TITLE ObjectContainer.view_group = 'List' ObjectContainer.art = R(ART) DirectoryObject.thumb = R(ICON) DirectoryObject.art = R(ART) VideoClipObject.thumb = R(ICON) VideoClipObject.art = R(ART) HTTP.CacheTime = 3600 HTTP.Headers['User-Agent'] = USER_AGENT cerealizer.register(sc2casts.SC2Cast)
def Start(): Plugin.AddPrefixHandler(PLUGIN_PREFIX, MainMenu, u"SVT Play 2", THUMB, ART) Plugin.AddViewGroup(name='VideoGrid', viewMode='Episodes', mediaType='videos') Plugin.AddViewGroup(name='ProgramList', viewMode='Episodes', mediaType='videos') Plugin.AddViewGroup(name='List', viewMode='List', mediaType='videos') #HTTP.CacheTime = CACHE_TIME_SHORT #HTTP.PreCache(URL_DEVICECONF) ObjectContainer.title1 = "SVT Play" ObjectContainer.art = R(ART) DirectoryObject.thumb = R(THUMB) VideoClipObject.thumb = R(THUMB) cerealizer.register(menuitem.MenuItem)
def test_alias1(self): class OldObj(object): def __init__(self): self.x = 1 self.name = "jiba" cerealizer.register(OldObj) o = OldObj() s = cerealizer.dumps(o) reload(cerealizer) class NewObj(object): def __init__(self): self.x = 2 self.name = "jiba2" cerealizer.register(NewObj) cerealizer.register_alias(NewObj, "__main__.OldObj") o = cerealizer.loads(s) assert o.__class__ is NewObj assert o.x == 1 assert o.name == "jiba"
def test_alias(self): class OldObj(object): def __init__(self): self.x = 1 self.name = "jiba" cerealizer.register(OldObj) o = OldObj() s = cerealizer.dumps(o) imp.reload(cerealizer) class NewObj(object): def __init__(self): self.x = 2 self.name = "jiba2" cerealizer.register(NewObj) cerealizer.register_alias(NewObj, "__main__.OldObj") o = cerealizer.loads(s) assert o.__class__ is NewObj assert o.x == 1 assert o.name == "jiba"
def export(test): filename = os.path.join(os.path.dirname(sys.argv[0]), test.lower() + ".dat") clsname = test + "_class" f = open(filename, "wb") try: cls = globals()[clsname] except KeyError: print "Test '%s' not defined." % (test) sys.exit(1) try: cerealizer.register(cls, classname=clsname) obj = cls() cerealizer.dump(obj, f) f.close() except Exception as e: print "Error exporting '%s': %s" % (test, e) sys.exit(1) print "Exported %s" % filename
def register_all(extras = []): """! Register our known serializables. @param extras extra class/mod names to allow serialization @good OK 20080102 bryon """ global _already_called if _already_called: return _already_called = True for module_name, class_names in chain(known, extras): before = sys.modules if type(class_names) == str: class_names = [ class_names ] module = __import__(module_name, globals(), locals(), class_names) for class_name in class_names: clas = getattr(module, class_name) # this has to be ugly to maintain backwards crypto compatibility # internal classnames that cerealizer picks up/picked up on changed from PyCrypto 2.0.1 -> 2.1.0 # as such we need to alias both the generated and read it classnames. # if any more changes need to happen here, or this gets called more than once per process # or we start multiprocessing for whatever reason, register_all will need a refactoring. if class_name == '_RSAobj': register(clas, classname = 'Crypto.PublicKey.RSA.RSAobj') else: register(clas) if module_name in aliases: for alias in aliases[module_name]: clas = getattr(module,alias[0]) register_alias(clas, '.'.join((module_name, alias[1]))) sys.modules = before
def Start(): Plugin.AddPrefixHandler(PLUGIN_PREFIX, MainMenu, TEXT_TITLE, "icon-default.png", "art-default.jpg") Plugin.AddViewGroup(name="List") HTTP.CacheTime = CACHE_TIME_SHORT HTTP.PreCache(URL_INDEX) ObjectContainer.art = R(ART) DirectoryObject.thumb = R(THUMB) cerealizer.register(ShowInfo) cerealizer.register(EpisodeInfo) cerealizer.register(CategoryInfo)
def enable_cerealizer(local, network): """enable_cerealizer(local, network) Use the Cerealizer serialization module for LOCAL and/or NETWORK serialization. Set LOCAL to 1 to use Cerealizer for local serialization (else use 0). Set NETWORK to 1 to use Cerealizer for remote serialization (else use 0). E.g. to use Cerealizer for both local file and network transfer, do: enable_cerealizer(1, 1) and to use Cerealizer for only for network transfer, do: enable_cerealizer(0, 1) """ cerealizer.register(LocalController) cerealizer.register(LocalDoer) cerealizer.register(RemoteController) cerealizer.register(RemoteDoer) global local_serializer, network_serializer if local : local_serializer = cerealizer if network: network_serializer = cerealizer
import cerealizer import time #import psyco #psyco.full() class O(object): def __init__(self): self.x = 1 self.s = "jiba" self.o = None self.l = [1, 2, 3, 4] cerealizer.register(O) cerealizer.freeze_configuration() l = [] for i in range(20000): o = O() if l: o.o = l[-1] l.append(o) print("cerealizer") t = time.time() s = cerealizer.dumps(l) print("dumps in", time.time() - t, "s,", len(s), "bytes length") t = time.time()
soya.MAIN_LOOP.camera.add_traveling(traveling) soya.MAIN_LOOP.camera.zap() class Bot(Mobile): def __init__(self): Mobile.__init__(self) self.counter = 0 def generate_action(self): self.counter += 1 if self.counter == 35: self.plan_action(Action(self, ACTION_MOVE_FORWARD)) elif self.counter == 55: self.plan_action(Action(self, ACTION_MOVE_BACKWARD)); self.counter = 0 cerealizer.register(Mobile) cerealizer.register(Bot) cerealizer.register(Level , soya.cerealizer4soya.SavedInAPathHandler(Level )) cerealizer.register(Player, soya.cerealizer4soya.SavedInAPathHandler(Player)) if mode == "server": create_demo_level() elif mode == "client": soya.init("Soya & Tofu demo", 640, 480) tofu_udp.LOGIN = sys.argv[2] tofu_udp.PASSWORD = "******" if len(sys.argv) >= 4: tofu_udp.HOST = sys.argv[3] elif mode == "single": create_demo_level()
class Edition(object): def __init__(self, root, current = None, parent = None): self.root = root self.current = current or root self.parent = parent or None self._id2obj = { 0 : None } self._obj2id = { None : 0 } def edit(self, current, parent): self.current = current self.parent = parent def obj2id(self, obj): id = self._obj2id.get(obj) if not id: id = len(self._obj2id) self._obj2id[obj] = id self._id2obj[id ] = obj return id def id2obj(self, id): return self._id2obj[id] def dumps(self): return base64.encodestring(cerealizer.dumps(self)) cerealizer.register(Edition)
def __repr__(self): return 'Redirect(%s)' % (repr( self.__dict__['_Object__headers']['Location'])) #################################################################################################### class MetadataSearchResult(XMLObject): def __init__(self, core, id, name=None, year=None, score=0, lang=None, thumb=None): XMLObject.__init__(self, core, id=id, thumb=thumb, name=name, year=year, score=score, lang=lang) self.tagName = "SearchResult" cerealizer.register(ItemInfoRecord)
def registerClasses(): """Registers the classes to serialize""" cerealizer.register(AF.AudioFileInfos)
def __new__(cls, name, bases, dct): cls = super(SerializableMetaclass, cls).__new__(cls, name, bases, dct) cerealizer.register(cls) return cls
class Obstacle(object): def __init__(self, position, size): pass #------------------------------------------------------------------------------ class SerialPolygon(object): def __init__(self, polygon): self.vertices = polygon.vertices self.texture_name = polygon.texture_name cerealizer.register(SerialPolygon) class Polygon(Entity): DEFAULT_TEXTURE = "data/textures/level/bluerock.png" def __init__(self, scene, batch=None, serial=None, texture_pair=None): super(Polygon, self).__init__() self.scene = scene self.vertices = [] self.edges = [] self.normals = [] self.uvmap = [] self.batch = batch or pyglet.graphics.Batch() self.pvl = self.batch.add(1, pyglet.gl.GL_TRIANGLES, None,
# # To each protocol corresponds a function like : # tofu.enable_<protocol>(enable_for_local, enable_for_network) # For Cerealizer + cPickle: # #tofu.enable_pickle (1, 0) #tofu.enable_cerealizer(0, 1) # For Cerealizer: # tofu.enable_cerealizer(1, 1) # Registers our classes as safe for Cerealizer # Level and Player class MUST be registred using the tofu.SavedInAPathHandler Cerealizer handler. import cerealizer cerealizer.register(Action) cerealizer.register(State) cerealizer.register(Mobile) cerealizer.register(Bot) cerealizer.register(PlayerCharacter) cerealizer.register(Level , tofu.SavedInAPathHandler(Level )) cerealizer.register(Player, tofu.SavedInAPathHandler(Player)) # Inits Tofu with our classes. tofu.init(GameInterface, Player, Level, Action, State, Mobile)
see servernet.py and clientnet.py """ import sys import socket import thread import Queue import traceback #import pickle import cerealizer # Register with Cerealizer the classes we need to be able to send over the # network import decimal cerealizer.register(decimal.Decimal) timeout = 10 """ Number of seconds the server waits for a message from the client before considering it disconnected """ ping_interval = 2 """ Number of seconds to wait after sending a message before sending a ping from client to server to let the server know the client is still alive """ msglen_width = 10 """ Number of characters to use in the zero-padded text representation of the message length field """ def sendmessage(sock, message): """ Send a complete pickled object over socket sock. message should be
( (not self.new_item) and datetime.datetime.utcnow() > self.next_check_date() ) ) ) def next_check_date(self): last_found_delta = self.date_last_item_check - self.date_last_item_found # If it's been less than 8 days since we found a new item, check every 3 hours at the most. if (last_found_delta.days <= 8): check_delta = 3 # If it's been more than 8 days, but less than 16, check every 8 hours at the most. elif (last_found_delta.days > 8 and last_found_delta.days <= 16): check_delta = 8 # If it's been more than 16 days, but less than 32, check every 12 hours at the most. elif (last_found_delta.days > 16 and last_found_delta.days <= 32): check_delta = 12 # If it's been more than 32 days, check once every 24 hours at the most. elif (last_found_delta.days > 32): check_delta = 24 return self.date_last_item_check + timedelta(minutes=check_delta * 60 - 0.5) cerealizer.register(FavouriteItems) cerealizer.register(FavouriteItem)
self.SetHeader("Location", str(url)) def Status(self): return "301 Moved Permanently" def __repr__(self): return 'Redirect(%s)' % (repr( self.__dict__['_Object__headers']['Location'])) def Content(self): return "" #################################################################################################### cerealizer.register(Object) cerealizer.register(Container) cerealizer.register(XMLObject) cerealizer.register(XMLContainer) cerealizer.register(DataObject) cerealizer.register(ItemInfoRecord) cerealizer.register(ContextMenu) cerealizer.register(MediaContainer) cerealizer.register(MessageContainer) cerealizer.register(DirectoryItem) cerealizer.register(PopupDirectoryItem) cerealizer.register(InputDirectoryItem) cerealizer.register(VideoItem) cerealizer.register(WebVideoItem) cerealizer.register(RTMPVideoItem) cerealizer.register(WindowsMediaVideoItem)
def test_register2(self): class Sec2: pass cerealizer.register(Sec2) self.assertRaises(ValueError, lambda: cerealizer.register(Sec2))
#Log('Trying to add item :' + played_url + ' to watched list.') if (not self.has_been_watched(played_url)): self.watched_items.append([path, played_url]) def mark_unwatched(self, url): elems = [elem for elem in self.watched_items if url == elem[1]] for elem in elems: self.watched_items.remove(elem) def has_been_watched(self, url): if (isinstance(url, basestring)): url_set = set([url]) else: url_set = set(url) return url_set.issubset([x[1] for x in self.watched_items]) def __len__(self): return len(self.recent_items) cerealizer.register(BrowsedItems) cerealizer.register(ViewedItems)
pass self.SetHeader("Location", location) def Status(self): # Special case for CORS requests, since CORS requests requiring preflight # can't be redirected. try: request = self._core.sandbox.context.request if request and 'Origin' in request.headers and not request.host in request.headers['Origin']: return 200 except: pass return 302 if self._temporary else 301 def Content(self): return '' def __repr__(self): return 'Redirect(%s)' % (repr(self.__dict__['_Object__headers']['Location'])) #################################################################################################### class MetadataSearchResult(XMLObject): def __init__(self, core, id, name=None, year=None, score=0, lang=None, thumb=None): XMLObject.__init__(self, core, id=id, thumb=thumb, name=name, year=year, score=score, lang=lang) self.tagName = "SearchResult" cerealizer.register(ItemInfoRecord)
############################################################################### def Start(): # default cache time HTTP.SetCacheTime(C["CACHE_TTL"]) # Prefetch some content # HTTP.PreCache(_GameListURL(), cacheTime=C["GAME_CACHE_TTL"]) Plugin.AddPrefixHandler(C["PLUGIN_PREFIX"], MainMenu, C["PLUGIN_NAME"] + ((" (" + str(C["PLUGIN_VERSION"]) + ")") if C["VERSION_IN_PLUGIN_NAME"] else ""), 'icon-default.png', 'art-default.jpg') Plugin.AddViewGroup("List", viewMode="List", mediaType="items") Plugin.AddViewGroup("Details", viewMode="InfoList", mediaType="items") ############################################################################### def CreatePrefs(): Prefs.Add('team', type='enum', default='(None)', label='Favorite Team', values=TeamList.toOptions()) Prefs.Add('login', type='text', default='', label='MLB.com Login') Prefs.Add('password', type='text', default='', label='MLB.com Password', option='hidden') Prefs.Add('allowspoilers', type='bool', default=True, label='Show spoilers for in-progress and completed games') ############################################################################### def UpdateCache(): HTTP.Request(C["URL"]["TOP_VIDEOS"]) def ValidatePrefs(): return Redirect(C["PLUGIN_PREFIX"]) cerealizer.register(Classes.Game.Game) cerealizer.register(Classes.GameStreamList.GameStreamList) cerealizer.register(Classes.Stream.Stream) cerealizer.register(Classes.Team.Team)
line = s.readline().decode('unicode_escape') if line and (line[-1] == '\n'): line = line[:-1] return datetime.date(line.encode("latin")) class TimeHandler(cerealizer.Handler): classname = 'time\n' def dump_obj(self, obj, dumper, s): assert issubclass(obj.__class__, datetime.time) if obj.tzinfo != None: raise ValueError("DatetimeHandler doesn't yet know how to handle datetime objects with tzinfo.") s.write(self.classname.encode("utf8")) s.write(obj.__reduce__()[1][0].decode("latin").encode('unicode_escape')) s.write(b'\n') def undump_obj(self, dumper, s): line = s.readline().decode('unicode_escape') if line and (line[-1] == '\n'): line = line[:-1] return datetime.time(line.encode("latin")) cerealizer.register(datetime.datetime, DatetimeHandler()) cerealizer.register(datetime.date , DateHandler ()) cerealizer.register(datetime.time , TimeHandler ())
played_url = path[-1]['url'] #Log('Trying to add item :' + played_url + ' to watched list.') if (not self.has_been_watched(played_url)): self.watched_items.append([path, played_url]) def mark_unwatched(self, url): elems = [elem for elem in self.watched_items if url == elem[1]] for elem in elems: self.watched_items.remove(elem) def has_been_watched(self, url): if (isinstance(url, basestring)): url_set = set([url]) else: url_set = set(url) return url_set.issubset([x[1] for x in self.watched_items]) def __len__(self): return len(self.recent_items) cerealizer.register(BrowsedItems) cerealizer.register(ViewedItems)
import sys, os, os.path, soya import cerealizer # Create a class of rotating body. See tuto basic-2 for more information on this. # Notice that you can add attribute to your class, and they will be automatically saved. class RotatingBody(soya.Body): def advance_time(self, proportion): soya.Body.advance_time(self, proportion) self.rotate_y(proportion * 5.0) # Register the RotatingBody class as safe for Cerealizer. cerealizer.register(RotatingBody) # The cerealizer.register accept any Python classes. Wether a class inherits from a Soya class # (such as, here, Body) or not, doesn't change anything. # However, if your class inherits from World, Image, Model, Material, you have to do something # special if you want to use YourClass.get() or YourClass.save(). This involves actually any # SavedInAPath object, i.e. any object Soya saves in a specific subpath of soya.path. # # E.g. for a World, you should do: # #import soya.cerealizer4soya #class YourWorld(soya.World): # pass #cerealizer.register(YourWorld, soya.cerealizer4soya.SavedInAPathHandler(YourWorld)) # # And then you can use YourWorld.get("filename") and so on.