def deserialize(doc):
brl = BRLUser(doc[User.SERIAL_ID_KEY])
user = User(brl)
user._encrypted_password = doc[User.SERIAL_ENCRYPTED_PASSWORD]
user.password_timestamp = doc.get(User.SERIAL_PASSWORD_TIMESTAMP, None)
if User.SERIAL_NUMERIC_ID in doc:
user.numeric_id = ID.deserialize(doc[User.SERIAL_NUMERIC_ID])
# Profile fields
user.firstname = doc.get(User.SERIAL_FIRSTNAME, None)
user.lastname = doc.get(User.SERIAL_LASTNAME, None)
user.country = doc.get(User.SERIAL_COUNTRY, None)
user.description = doc.get(User.SERIAL_DESCRIPTION, None)
user.email = doc.get(User.SERIAL_EMAIL, None)
user.visible_email = doc.get(User.SERIAL_VISIBLE_EMAIL, 0) == 1
user.allow_mailing = doc.get(User.SERIAL_ALLOW_MAILING, 0) == 1
user.active = doc.get(User.SERIAL_ACTIVE, 0) == 1
user.staff = doc.get(User.SERIAL_STAFF, 0) == 1
user.joined_date = UtcDatetime.deserialize(
doc.get(User.SERIAL_JOINED_DATE, None))
user.confirmation_date = UtcDatetime.deserialize(
doc.get(User.SERIAL_CONFIRMATION_DATE, None))
user.confirmation_token = doc.get(User.SERIAL_CONFIRMATION_TOKEN, None)
# Old workspace methods
user.block_counter = doc.get(User.SERIAL_MOD_COUNTER, 0)
blocks_data = doc.get(User.SERIAL_BLOCKS, {})
user.blocks = DictDeserializer(
BRLBlock, BlockMetaInfoDeserializer).deserialize(blocks_data)
user.administrators = Permissions.deserialize(
doc.get(User.SERIAL_ADMINISTRATORS, {}))
social_accounts_doc = doc.get(User.SERIAL_SOCIAL_ACCOUNTS)
user.social_accounts = DictDeserializer(
str, SocialAccount).deserialize(social_accounts_doc)
# Achievements
user.read_api_counter = doc.get(User.SERIAL_READ_API_COUNTER, 0)
user.publish_counter = doc.get(User.SERIAL_PUBLISH_COUNTER, 0)
user.reuse_counter = doc.get(User.SERIAL_REUSE_COUNTER, 0)
# Additional profile fields
user.street_1 = doc.get(User.SERIAL_STREET1, "")
user.street_2 = doc.get(User.SERIAL_STREET2, "")
user.city = doc.get(User.SERIAL_CITY, "")
user.postal_code = doc.get(User.SERIAL_POSTAL_CODE, "")
user.region = doc.get(User.SERIAL_REGION, "")
user.tax_id = doc.get(User.SERIAL_TAX_ID, "")
user.vat = doc.get(User.SERIAL_VAT, "")
# OAuth
user.oauth_github_token = doc.get(User.SERIAL_OAUTH_GITHUB_TOKEN, None)
user.oauth_google_token = doc.get(User.SERIAL_OAUTH_GOOGLE_TOKEN, None)
# Max workspace size, default BII_MAX_USER_WORKSPACE_SIZE
user.max_workspace_size = doc.get(User.SERIAL_MAX_WORKSPACE_SIZE,
BII_MAX_USER_WORKSPACE_SIZE)
# Invited by
user.invited_by = doc.get(User.SERIAL_INVITED_BY, None)
return user
def deserialize(data):
'''From dictionary to object Publish Pack'''
pp = PublishRequest()
pp.parent = BlockVersion.deserialize(
data[PublishRequest.SERIAL_TRACKED_KEY])
pp.parent_time = data[PublishRequest.SERIAL_PARENT_DATETIME]
pp.tag = VersionTag.deserialize(data[PublishRequest.SERIAL_TAG_KEY])
pp.msg = data[PublishRequest.SERIAL_MSG_KEY]
# Backward client compatibility
pp.versiontag = data.get(PublishRequest.SERIAL_VTAG_KEY, None)
pp.deptable = BlockVersionTable.deserialize(
data[PublishRequest.SERIAL_DEP_TABLE])
pp.cells = ListDeserializer(CellDeserializer(BlockCellName)).\
deserialize(data[PublishRequest.SERIAL_CELLS_KEY])
pp.deleted = ListDeserializer(CellName).\
deserialize(data[PublishRequest.SERIAL_DELETED_KEY])
pp.renames = Renames.deserialize(
data[PublishRequest.SERIAL_RENAMES_KEY])
pp.contents = DictDeserializer(CellName, ContentDeserializer(BlockCellName)).\
deserialize(data[PublishRequest.SERIAL_CONTENTS_KEY])
pp.contents_ids = DictDeserializer(CellName, ID).\
deserialize(data[PublishRequest.SERIAL_CONTENTS_ID_KEY])
# Backward client compatibility
pp.origin = OriginInfo.deserialize(
data.get(PublishRequest.SERIAL_ORIGIN_INFO, None))
return pp
def deserialize(data):
d = DictDeserializer(
BlockVersion,
DictDeserializer(Declaration,
SetDeserializer(BlockCellName))).deserialize(data)
result = ReferencedDependencies()
result.update(d)
return result
def deserialize(data):
d = DictDeserializer(
BlockVersion,
DictDeserializer(
CellName,
ResourceDeserializer(
CellDeserializer(ID),
ContentDeserializer(ID)))).deserialize(data)
result = ReferencedResources()
result.update(d)
return result
def deserialize(self, data, kls=None):
"""From dictionary to object Changes"""
kls = kls or Changes
#NOTE: ID always is CellName, and values are text tuples, if not, we cant deserialize
ret = kls()
ret.deleted = self.dict_values_deserializer.deserialize(data[Changes.SERIAL_DELETED_KEY])
renames_deserializer = DictDeserializer(self.keys_deserializer, self.keys_deserializer)
ret.renames = renames_deserializer.deserialize(data[Changes.SERIAL_RENAMES_KEY])
ret.created = self.dict_values_deserializer.deserialize(data[Changes.SERIAL_CREATED_KEY])
#ret.modified = self.values_deserializer.deserialize(data[Changes.SERIAL_MODIFIED_KEY])
mod_deserial = DictDeserializer(self.keys_deserializer,
ModificationDeserializer(self.values_deserializer))
ret.modified = mod_deserial.deserialize(data[Changes.SERIAL_MODIFIED_KEY])
ret.sim_limit = data[Changes.SERIAL_SIMLIMIT_KEY]
return ret
def deserialize(data):
if data is None:
return None
d = DictDeserializer(BlockVersion,
SetDeserializer(CellName)).deserialize(data)
result = References()
result.update(d)
return result
def testDeserializeDict(self):
brl = BlockCellName("user/block/path/file.h")
brl2 = BlockCellName("user/block/path/file2.h")
h = {brl.serialize(): "asasdasdasd",
brl2.serialize(): "1123"
}
ret = DictDeserializer(BlockCellName, str).deserialize(h)
self.assertEqual(ret, {'user/block/path/file.h': 'asasdasdasd',
'user/block/path/file2.h': '1123'})
h = {brl.serialize(): brl.serialize(),
brl2.serialize(): brl.serialize()
}
ret = DictDeserializer(BlockCellName, BlockCellName).deserialize(h)
self.assertEqual(ret,
{'user/block/path/file.h': 'user/block/path/file.h',
'user/block/path/file2.h': 'user/block/path/file.h'}
)
class ChangesDeserializer(object):
def __init__(self, keys_deserializer, values_deserializer):
self.keys_deserializer = keys_deserializer
self.values_deserializer = values_deserializer
self.dict_values_deserializer = DictDeserializer(keys_deserializer, values_deserializer)
def deserialize(self, data, kls=None):
"""From dictionary to object Changes"""
kls = kls or Changes
#NOTE: ID always is CellName, and values are text tuples, if not, we cant deserialize
ret = kls()
ret.deleted = self.dict_values_deserializer.deserialize(data[Changes.SERIAL_DELETED_KEY])
renames_deserializer = DictDeserializer(self.keys_deserializer, self.keys_deserializer)
ret.renames = renames_deserializer.deserialize(data[Changes.SERIAL_RENAMES_KEY])
ret.created = self.dict_values_deserializer.deserialize(data[Changes.SERIAL_CREATED_KEY])
#ret.modified = self.values_deserializer.deserialize(data[Changes.SERIAL_MODIFIED_KEY])
mod_deserial = DictDeserializer(self.keys_deserializer,
ModificationDeserializer(self.values_deserializer))
ret.modified = mod_deserial.deserialize(data[Changes.SERIAL_MODIFIED_KEY])
ret.sim_limit = data[Changes.SERIAL_SIMLIMIT_KEY]
return ret
def deserialize(data):
targets_deserializer = DependencySet.targets_deserializer
declaration_deserializer = DependencySet.declaration_deserializer
r = DependencySet()
r.explicit = targets_deserializer.deserialize(
data[DependencySet.SERIAL_EXPLICIT])
r.implicit = targets_deserializer.deserialize(
data[DependencySet.SERIAL_IMPLICIT])
r.system = SetDeserializer(SystemCellName).deserialize(
data[DependencySet.SERIAL_SYSTEM])
r.resolved = declaration_deserializer.deserialize(
data[DependencySet.SERIAL_RESOLVED])
r.unresolved = declaration_deserializer.deserialize(
data[DependencySet.SERIAL_UNRESOLVED])
try:
d = data[DependencySet.SERIAL_PROPERTIES]
r.properties = DependenciesProperties.deserialize(d)
except KeyError:
pass
try:
d = data[DependencySet.SERIAL_PATHS]
r.paths = DictDeserializer(int, str).deserialize(d)
except KeyError:
pass
# This 2 latter are backward compatibility deserializations
# TODO: Can be removed with a migration
try:
d = data[DependencySet.SERIAL_DATA]
items = targets_deserializer.deserialize(d)
for item in items:
r.explicit.add(item)
r.properties.add_property(item, DependenciesProperties.DATA)
except KeyError:
pass
try:
d = data[DependencySet.SERIAL_EXCLUDE]
items = targets_deserializer.deserialize(d)
for item in items:
r.properties.add_property(
item, DependenciesProperties.EXCLUDE_FROM_BUILD)
except KeyError:
pass
return r
def test_deserialize_none(self):
dd = DictDeserializer(str, str)
self.assertIsNone(dd.deserialize(None))
def deserialize(doc, block_id):
m = AddressTable(block_id)
tmp = DictDeserializer(CellName, TimeBaseMapDeserializer(ID)).deserialize(doc)
m.update(tmp)
return m
def deserialize(data):
return Renames(DictDeserializer(CellName, CellName).deserialize(data))
def deserialize(data):
if data is None:
return None
d = DictDeserializer(BlockCellName,
SetDeserializer(str)).deserialize(data)
return DependenciesProperties(d)
def deserialize(data):
deserializer = DictDeserializer(str, str)
return UserSettings(deserializer.deserialize(data))
def __init__(self, keys_deserializer, values_deserializer):
self.keys_deserializer = keys_deserializer
self.values_deserializer = values_deserializer
self.dict_values_deserializer = DictDeserializer(keys_deserializer, values_deserializer)
def deserialize(data):
deserializer = DictDeserializer(str, str)
return UserSettings(deserializer.deserialize(data))
