def apply_changes(self):
# prev_id = self.id
for data_list, property_names in self._changes_queue:
object_util.set_up_object(self, data_list, property_names)
self.change_time = time.time()
# self._check_id_changed(prev_id, self.id)
self._changes_queue.clear()
def test_set_up_object_with_empty_params_and_value_obj(self):
# Set up
dic = {"a": 1, "b": 2, "c": 3}
value_obj = Values(c=None) # {"a": 5, "c": None, "e": 8}
property_name_list = None
expected_dic = {
"a": 1,
"b": 2,
"c": 3
} # {"a": 5, "b": 2, "c": 3, "e": 8}
# Assert
object_util.set_up_object(dic, value_obj)
self.assertEqual(dic, expected_dic)
# Test empty dic
# Set up
dic = {}
value_obj = Values(e=None) # {"a": 5, "c": 7, "e": None}
property_name_list = None
expected_dic = {} # {"a": 5, "c": 7}
# Assert
object_util.set_up_object(dic, value_obj)
self.assertEqual(dic, expected_dic)
def test_set_up_object_with_defaults_to_skip(self):
# Set up
dic = {"a": 1, "b": 2, "c": 3}
value_dic = {"a": 21, "b": 22, "c": 23}
defaults = {"a": 1, "b": 22, "c": 23}
expected_dic = {"a": 21, "b": 2, "c": 3}
# Assert
object_util.set_up_object(dic, value_dic, defaults_to_skip=defaults)
self.assertEqual(dic, expected_dic)
def reset(self):
object_util.set_up_object(self, self.defaults,
self._config_property_names)
super().reset()
# ?
for sub_model in self._sub_models:
sub_model.reset()
# Apply sub_models on the model
self._is_changed = True # To apply sub_models after their reset
self.apply_changes()
def copy(self):
if self.parent_model:
# Avoiding big trees (more than one level)!
# (The normal is when one super contains several derived models which could not be super models themselves)
return self.parent_model.copy()
model = self.__class__(self._initial_config)
# (Apply changes different of initial_config)
object_util.set_up_object(model, self, self._property_names)
model.parent_model = self
self.derived_models.append(model)
return model
def test_set_up_object_dic_with_value_dic(self):
# Test dic as obj and values as dict
# Set up
dic = {"a": 1, "b": 2, "c": 3}
obj = SimpleObject()
value_dic = {"a": 5, "c": None, "e": 8}
property_name_list = ["a", "b", "c"]
expected_dic = {"a": 5, "b": 2, "c": 3}
# Assert
object_util.set_up_object(dic, value_dic, property_name_list)
self.assertEqual(dic, expected_dic)
object_util.set_up_object(obj, value_dic, property_name_list)
self.assertEqual(obj.a, 5)
self.assertEqual(obj.b, 2)
self.assertEqual(obj.c, 3)
# Set up
dic = {"a": 1, "b": 2, "c": 3}
obj = SimpleObject()
value_dic = {"a": 5, "c": 7, "e": 8}
property_name_list = None
expected_dic = {"a": 5, "b": 2, "c": 7, "e": 8}
# Assert
object_util.set_up_object(dic, value_dic)
self.assertEqual(dic, expected_dic)
object_util.set_up_object(obj, value_dic, property_name_list)
self.assertEqual(obj.a, 5)
self.assertEqual(obj.b, 2)
self.assertEqual(obj.c, 7)
def __init__(self, initial_config=None, ids=None):
self._sub_models = []
# (Set all default values before this)
self.defaults = {}
object_util.set_up_object(self.defaults, self,
self._config_property_names)
super().__init__(initial_config)
# (Must be after _sub_models)
self.ids = ids
if self.is_change_on_command:
self.apply_changes()
def on_reload(self, new_initial_config=None):
"""
On initial data reloaded, do updates.
:param new_initial_config:
:return:
"""
if not new_initial_config:
return
new_initial_config = self.resolve_info(new_initial_config)
# For reset()
# self._initial_config = new_initial_config
self._check_id_changed(new_initial_config, self.id_name)
self._check_id_changed(new_initial_config, "id")
object_util.set_up_object(self._initial_config, new_initial_config,
self._property_names)
# For apply_changes() if is_change_on_command==True
self.import_data(new_initial_config)
def import_public_data(self, data_list):
"""
Import state received from another server or client
(should be saved using export_public_data()).
Properties are parsed in order of self._property_names.
Used to update state of current object, to synchronize states between clients and servers.
:param data_list:
:return:
"""
if self.is_change_on_command:
if object_util.has_changes(self, data_list,
self._public_property_names):
self._changes_queue.append(
(data_list, self._public_property_names))
else:
object_util.set_up_object(self, data_list,
self._public_property_names)
self.change_time = time.time()
def test_set_up_object_with_referenced_values_in_obj(self):
# Set up
dic = {"a": 1, "b": 2, "c": 3}
value_obj = Values(a=[1, 2, {
"u": "x"
}],
b={
2: 3,
"4": 5,
"u": SimpleObject(55)
},
c=None,
e=None)
property_name_list = ["a", "b", "c"]
expected_dic = {
"a": [1, 2, {
"u": "x"
}],
"b": {
2: 3,
"4": 5,
"u": SimpleObject(55)
},
"c": 3
}
# Assert
object_util.set_up_object(dic, value_obj, property_name_list)
self.assertEqual(dic, expected_dic)
# Changes in dic should not affect value_dic
dic["a"].append(3)
dic["b"]["6"] = 7
# (More nested)
dic["a"][2]["u"] = "yy"
dic["b"]["u"].a = "zz"
self.assertEqual(value_obj.a, [1, 2, {"u": "x"}])
self.assertEqual(value_obj.b, {2: 3, "4": 5, "u": SimpleObject(55)})
# Assert (if values are the same, then expected are the same too)
object_util.set_up_object(dic, value_obj, property_name_list)
self.assertEqual(dic, expected_dic)
def test_set_up_object_with_referenced_values_in_dic(self):
# Set up
dic = {"a": 1, "b": 2, "c": 3}
value_dic = {
"a": [1, 2, {
"u": "x"
}],
"b": {
2: 3,
"4": 5,
"u": SimpleObject(55)
}
}
expected_dic = {
"a": [1, 2, {
"u": "x"
}],
"b": {
2: 3,
"4": 5,
"u": SimpleObject(55)
},
"c": 3
}
# Assert
object_util.set_up_object(dic, value_dic)
self.assertEqual(dic, expected_dic)
# Changes in dic should not affect value_dic
dic["a"].append(3)
dic["b"]["6"] = 7
# (More nested)
dic["a"][2]["u"] = "yy"
dic["b"]["u"].a = "zz"
self.assertEqual(value_dic["a"], [1, 2, {"u": "x"}])
self.assertEqual(value_dic["b"], {2: 3, "4": 5, "u": SimpleObject(55)})
# Assert (if values are the same, then expected are the same too)
object_util.set_up_object(dic, value_dic)
self.assertEqual(dic, expected_dic)
def test_set_up_object_dic_with_value_list(self):
# Test dic as obj and values as list
# Set up
dic = {"a": 1, "b": 2, "c": 3}
obj = SimpleObject()
value_list = [5, None, 7]
property_name_list = ["a", "b"]
expected_dic = {"a": 5, "b": 2, "c": 3}
# Assert
object_util.set_up_object(dic, value_list, property_name_list)
self.assertEqual(dic, expected_dic)
self.assertEqual(obj.a, 1)
self.assertEqual(obj.b, 2)
self.assertEqual(obj.c, 3)
object_util.set_up_object(obj, value_list, property_name_list)
self.assertEqual(obj.a, 5)
self.assertEqual(obj.b, 2)
self.assertEqual(obj.c, 3)
def import_data(self, data):
"""
Import saved state (should be saved using export_data()).
Properties are parsed in order of self._property_names.
Used to restore model, for example, after server restart.
:param data:
:return:
"""
if self.is_change_on_command:
if object_util.has_changes(self, data, self._property_names):
# (Makes is_changed=True)
self._changes_queue.append((data, self._property_names))
else:
# prev_id = self.id
object_util.set_up_object(self, data, self._property_names)
# self._check_id_changed(prev_id, self.id)
self.change_time = time.time()
# (For overriden apply_changes())
self.apply_changes()
def test_set_up_object_with_empty_params_and_value_list(self):
# Set up
dic = None
value_list = [5, 6, 7]
property_name_list = ["a", "b"]
expected_dic = None
# Assert
object_util.set_up_object(dic, value_list, property_name_list)
self.assertEqual(dic, expected_dic)
# Set up
dic = {"a": 1, "b": 2, "c": 3}
value_list = None
property_name_list = ["a", "b"]
expected_dic = {"a": 1, "b": 2, "c": 3}
# Assert
object_util.set_up_object(dic, value_list, property_name_list)
self.assertEqual(dic, expected_dic)
# Set up
dic = {"a": 1, "b": 2, "c": 3}
value_list = [5, 6, 7]
property_name_list = None
expected_dic = {"a": 1, "b": 2, "c": 3}
# Assert
object_util.set_up_object(dic, value_list, property_name_list)
self.assertEqual(dic, expected_dic)
def __init__(self,
default_host="",
default_port=0,
house_id=0,
data_dir_path=None,
**kwargs):
ServerConfig.__init__(self, default_host, default_port)
self.logging = _logging.getLogger("CONFIG")
self.house_id = str(house_id)
self._data_dir_path = data_dir_path or ""
# kwargs - to set up properties above (xxx_class, xxx_path)
object_util.set_up_object(self, kwargs)
# (Needed to resolve class loading without errors (HouseModel shouldn't know about LobbyModel))
HouseModel.lobby_model_class = self.lobby_model_class
# HouseModel.game_config_model_class = self.game_config_model_class
# LobbyModel.room_model_class = self.room_model_class
# Apply model classes from config
# (Don't override __init__ to change these classes)
GameConfigModel.model_class = self.game_config_model_class
RoomModel.model_class = self.room_model_class
LobbyModel.model_class = self.lobby_model_class
HouseModel.model_class = self.house_model_class
# # Backend is a php server to which we should make requests to save any game progress
# self.backend_domain = None
# # Social app secret (to check auth_sig)
# self.app_secret = None
# # Secret key to make secured requests to php server
# self.napalm_secret = None
self._backend_info_by_backend = {}
self._load_data()
self.house_model = HouseModel.get_model_by_id(self.house_id)
def apply_changes(self):
# self._initial_config = {}
id = self.id
# Apply changes for each sub model this model consists of
for sub_model in self._sub_models:
# if sub_model.is_available and (self.is_changed or sub_model.is_changed):
if sub_model.is_available:
# # For sub_models on_reload()
# object_util.set_up_object(self._initial_config, sub_model._initial_config, self._property_names)
sub_model.apply_changes()
# (_config_property_names doesn't contain "_changes_queue". Skipping defaults
# needed not to override properties with default values of the last sub_model)
object_util.set_up_object(self,
sub_model,
self._config_property_names,
defaults_to_skip=sub_model.defaults)
self.change_time = time.time()
self.id = id
self._is_changed = False
super().apply_changes()
def test_set_up_object_on_object_without_setter(self):
# Test obj without setter and values as dict
# Set up
obj = PropertyObject()
value_list = [5, 6, 7]
property_name_list = ["a", "b", "c"]
# Assert
self.assertEqual(obj.a, 1)
self.assertEqual(obj.b, 2)
self.assertEqual(obj.c, 3)
object_util.set_up_object(obj, value_list, property_name_list)
self.assertEqual(obj.a, 5)
self.assertEqual(obj.b, 6)
self.assertEqual(obj.c, 3)
# Set up
obj = PropertyObject()
value_dic = {"a": 5, "b": 6, "c": 7, "e": 8}
property_name_list = ["a", "b", "c"]
# Assert
object_util.set_up_object(obj, value_dic, property_name_list)
self.assertEqual(obj.a, 5)
self.assertEqual(obj.b, 6)
self.assertEqual(obj.c, 3)
# Set up
obj = PropertyObject()
value_dic = {"a": 5, "b": 6, "c": 7, "e": 8}
property_name_list = None
# Assert
object_util.set_up_object(obj, value_dic, property_name_list)
self.assertEqual(obj.a, 5)
self.assertEqual(obj.b, 6)
self.assertEqual(obj.c, 3)
def _apply_initial_config(self):
object_util.set_up_object(self, self._initial_config,
self._config_property_names)
def game_params(self, value):
self._game_params = value
object_util.set_up_object(self, self._game_params, self._game_property_name_list)