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.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
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)
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 test_new_hacked(self): class Sec6: pass cerealizer.register(Sec6) o = Sec6() Sec6.__new__ = lambda Class: self.fail() cerealizer.loads(cerealizer.dumps(o))
###############################################################################
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 ())
def __new__(cls, name, bases, dct):
cls = super(SerializableMetaclass, cls).__new__(cls, name, bases, dct)
cerealizer.register(cls)
return cls
def test_getstate_hacked(self): class Sec5: pass cerealizer.register(Sec5) o = Sec5() Sec5.__getstate__ = lambda obj: self.fail() cerealizer.loads(cerealizer.dumps(o))
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.
