def save(self, response_url=None, commit=True): tp = self.instance initialize_from_templates = False if tp.id is None: initialize_from_templates = tp.can_be_inited_from_templates() tp = super(TranslationProjectForm, self).save(commit) project = tp.project config = ObjectConfig(project) mappings = config.get("pootle.core.lang_mapping", {}) mappings = dict((v, k) for k, v in mappings.iteritems()) if not self.cleaned_data["fs_code"]: if tp.language.code in mappings: del mappings[tp.language.code] else: mappings[tp.language.code] = self.cleaned_data["fs_code"] config["pootle.core.lang_mapping"] = dict( (v, k) for k, v in mappings.iteritems()) if initialize_from_templates: def _enqueue_job(): queue = get_queue('default') queue.enqueue( update_translation_project, tp, response_url) connection.on_commit(_enqueue_job) return tp
def test_apiview_get_multi_config(rf): """Tests retrieving a single object with an m2m field using the API.""" view = UserConfigAPIView.as_view() user0 = UserFactory.create(username='******') user1 = UserFactory.create(username='******') request = create_api_request(rf) response = view(request) response_data = json.loads(response.content) for model in response_data["models"]: assert model["foo0"] is None assert model["foo1"] is None user_config = ObjectConfig(user0) user_config["foo0.bar"] = "user0.foo0.baz" user_config["foo1.bar"] = "user0.foo1.baz" user_config = ObjectConfig(user1) user_config["foo0.bar"] = "user1.foo0.baz" user_config["foo1.bar"] = "user1.foo1.baz" request = create_api_request(rf) response = view(request) response_data = json.loads(response.content) for model in response_data["models"]: if model["username"] in ["user0", "user1"]: model["foo0"] == "%s.foo0.baz" % model["username"] model["foo1"] == "%s.foo1.baz" % model["username"]
def save(self, response_url=None, commit=True): tp = self.instance initialize_from_templates = False if tp.id is None: initialize_from_templates = tp.can_be_inited_from_templates() tp = super(TranslationProjectForm, self).save(commit) project = tp.project config = ObjectConfig(project) mappings = config.get("pootle.core.lang_mapping", {}) mappings = dict((v, k) for k, v in mappings.iteritems()) if not self.cleaned_data["fs_code"]: if tp.language.code in mappings: del mappings[tp.language.code] else: mappings[tp.language.code] = self.cleaned_data["fs_code"] config["pootle.core.lang_mapping"] = dict( (v, k) for k, v in mappings.iteritems()) if initialize_from_templates: def _enqueue_job(): queue = get_queue('default') queue.enqueue(update_translation_project, tp, response_url) connection.on_commit(_enqueue_job) return tp
def test_config_object_util(): project = Project.objects.first() conf = ObjectConfig(project) assert conf.items() == conf.values() == conf.keys() == [] # keys are returned order by key other_dict = OrderedDict() other_dict["foo.a"] = "bar" other_dict["foo.b"] = dict(bar=23) other_dict["foo.c"] = [1, 2, 3] conf["foo.a"] = "bar" conf["foo.b"] = dict(bar=23) conf["foo.c"] = [1, 2, 3] assert conf.items() == other_dict.items() assert conf.values() == other_dict.values() assert conf.keys() == other_dict.keys() assert [x for x in conf] == other_dict.keys() assert all(x in conf for x in other_dict) assert all(conf[k] == v for k, v in other_dict.items()) assert all(conf.get(k) == v for k, v in other_dict.items()) assert conf.get("DOESNOTEXIST") is None assert conf.get("DOESNOTEXIST", "foo") == "foo" with pytest.raises(KeyError): conf["DOESNOTEXIST"] assert ObjectConfig(project).items() == other_dict.items() assert ObjectConfig(project).values() == other_dict.values() assert ObjectConfig(project).keys() == other_dict.keys() assert [x for x in ObjectConfig(project)] == other_dict.keys() assert all(x in ObjectConfig(project) for x in other_dict) assert all(ObjectConfig(project)[k] == v for k, v in other_dict.items()) assert all(ObjectConfig(project).get(k) == v for k, v in other_dict.items()) assert ObjectConfig(project).get("DOESNOTEXIST") is None assert ObjectConfig(project).get("DOESNOTEXIST", "foo") == "foo" with pytest.raises(KeyError): ObjectConfig(project)["DOESNOTEXIST"]
def delete_existing(self, tp, commit=True): config = ObjectConfig(tp.project) mapping = config.get("pootle.core.lang_mapping", {}) if tp.language.code in mapping: del mapping[tp.language.code] config["pootle.core.lang_mapping"] = mapping super(TranslationProjectFormSet, self).delete_existing(tp, commit=commit)
def delete_existing(self, tp, commit=True): config = ObjectConfig(tp.project) mapping = config.get("pootle.core.lang_mapping", {}) if tp.language.code in mapping: del mapping[tp.language.code] config["pootle.core.lang_mapping"] = mapping super(TranslationProjectFormSet, self).delete_existing( tp, commit=commit)
def serialize_config(self, info, item): config = ObjectConfig(item) for k, v in self.config: if k == "fs_mapping": mapping = config.get(v) or {} info[k] = mapping.get("default") else: info[k] = config.get(v) info["template_name"] = ( item.lang_mapper.get_upstream_code("templates"))
def test_lang_mapper_project_config(po_directory, english): project = ProjectDBFactory(source_language=english) project_config = ObjectConfig(project) # upstream_code="en_US", pootle_code="en" project_config["pootle.core.lang_mapping"] = dict(en_US="en") project.config.reload() mapper = lang_mapper.get(project.__class__, instance=project) assert mapper["en_US"] == english assert mapper.get_pootle_code("en_US") == "en" assert mapper.get_upstream_code("en") == "en_US" assert "en_US" in mapper # as en_US is mapped to pootle's en its not valid as upstream code assert mapper.get_upstream_code("en_US") is None # as en is mapped to en_US its not valid as a pootle_code assert mapper.get_pootle_code("en") is None assert "en" not in mapper # we can swap codes project_config["pootle.core.lang_mapping"] = dict(language0="en", en="language0") mapper = lang_mapper.get(project.__class__, instance=project) project.config.reload() language0 = Language.objects.get(code="language0") assert mapper["en"] == language0 assert mapper["language0"] == english assert mapper.get_pootle_code("en") == "language0" assert mapper.get_pootle_code("language0") == "en" assert mapper.get_upstream_code("en") == "language0" assert mapper.get_upstream_code("language0") == "en"
def test_apiview_get_single_config(rf): """Tests retrieving a single object with an m2m field using the API.""" view = UserConfigAPIView.as_view() user0 = UserFactory.create(username='******') user1 = UserFactory.create(username='******') request = create_api_request(rf) response = view(request, id=user0.id) response_data = json.loads(response.content) assert response_data["foo0"] is None assert response_data["foo1"] is None # string config user_config = ObjectConfig(user1) user_config["foo0.bar"] = "foo0.baz" user_config["foo1.bar"] = "foo1.baz" request = create_api_request(rf) response = view(request, id=user1.id) response_data = json.loads(response.content) assert response_data["foo0"] == "foo0.baz" assert response_data["foo1"] == "foo1.baz" # list config user_config["foo0.bar"] = ["foo0.baz"] user_config["foo1.bar"] = ["foo1.baz"] request = create_api_request(rf) response = view(request, id=user1.id) response_data = json.loads(response.content) assert response_data["foo0"] == ["foo0.baz"] assert response_data["foo1"] == ["foo1.baz"]
def tp0_store(po_directory, settings, tp0, fs_src): from pootle_config.utils import ObjectConfig from .store import _require_store conf = ObjectConfig(tp0.project) conf["pootle_fs.fs_type"] = "localfs" conf["pootle_fs.fs_url"] = fs_src conf["pootle_fs.translation_paths"] = OrderedDict(TRANSLATION_PATHS) return _require_store(tp0, settings.POOTLE_TRANSLATION_DIRECTORY, 'project0_fs.po')
def test_lang_mapper_bad_preset(po_directory, english, caplog): project = ProjectDBFactory(source_language=english) mapper = lang_mapper.get(project.__class__, instance=project) assert mapper.lang_mappings == {} project_config = ObjectConfig(project) project_config["pootle.core.use_lang_mapping_presets"] = [ "PRESET_DOES_NOT_EXIST" ] project.config.reload() mapper = lang_mapper.get(project.__class__, instance=project) assert mapper.lang_mappings == {} assert ("Unrecognised lang mapping preset" in ''.join([l.message for l in caplog.records]))
def _test_mapper(project, debug=False): project.config.reload() mapper = lang_mapper.get(project.__class__, instance=project) assert mapper.site_config.items() == SiteConfig().items() assert mapper.project.config.items() == ObjectConfig(project).items() assert mapper.project_mappings == ObjectConfig(project).get( "pootle.core.lang_mapping", {}) assert mapper.project_presets == ObjectConfig(project).get( "pootle.core.use_lang_mapping_presets", []) assert mapper.site_presets == SiteConfig().get( "pootle.core.lang_mapping_presets", {}) _preset_mappings = OrderedDict() for preset_name in mapper.project_presets: if preset_name not in mapper.site_presets: continue _preset_mappings.update(mapper.site_presets[preset_name]) assert mapper.mappings_from_presets == _preset_mappings _mapping = OrderedDict() def _add_lang_to_mapping(upstream_code, pootle_code): # as its a 1 to 1 mapping remove any previous items with # same value if pootle_code in _mapping.values(): for k, v in _mapping.items(): if v == pootle_code: del _mapping[k] break _mapping[upstream_code] = pootle_code mappings = OrderedDict(mapper.mappings_from_presets) mappings.update(OrderedDict(mapper.project_mappings)) for upstream_code, pootle_code in mappings.items(): _add_lang_to_mapping(upstream_code, pootle_code) assert mapper.lang_mappings == _mapping assert len(_mapping.values()) == len(set(_mapping.values()))
def test_lang_mapper_preset_config(po_directory, english): project = ProjectDBFactory(source_language=english) project_config = ObjectConfig(project) site_config = SiteConfig() # add the preset site_config["pootle.core.lang_mapping_presets"] = dict(preset_1=dict( en_US="en")) # project not configured yet tho mapper = lang_mapper.get(project.__class__, instance=project) assert mapper["en_US"] is None assert mapper["en"] == english # configure project to use preset project_config["pootle.core.use_lang_mapping_presets"] = ["preset_1"] project.config.reload() mapper = lang_mapper.get(project.__class__, instance=project) assert mapper["en_US"] == english assert mapper["en"] is None
def test_lang_mapper_mappings(english): project = ProjectDBFactory(source_language=english) _test_mapper(project) ObjectConfig(project)["pootle.core.lang_mapping"] = dict(lang0="language0") _test_mapper(project) ObjectConfig(project)["pootle.core.lang_mapping"] = dict( lang0="language1", lang1="language0") _test_mapper(project) SiteConfig()["pootle.core.lang_mapping_presets"] = dict( preset_1=dict(lang0="language1", lang1="language0")) _test_mapper(project) ObjectConfig(project)["pootle.core.lang_mapping"] = dict( lang0="language1", lang1="en") _test_mapper(project) ObjectConfig(project)["pootle.core.use_lang_mapping_presets"] = ["preset_1"] _test_mapper(project) ObjectConfig(project)["pootle.core.use_lang_mapping_presets"] = [ "preset_1", "preset_2"] _test_mapper(project) ObjectConfig(project)["pootle.core.lang_mapping"] = dict(lang1="language1") _test_mapper(project, True)
def serialize_config(self, info, item): config = ObjectConfig(item) for k, v in self.config: info[k] = config.get(v)
def config(self): return ObjectConfig(self)
def test_config_object_util(no_config_env): project = Project.objects.first() conf = ObjectConfig(project) assert conf.items() == conf.values() == conf.keys() == [] # keys are returned order by key other_dict = OrderedDict() other_dict["foo.a"] = "bar" other_dict["foo.b"] = dict(bar=23) other_dict["foo.c"] = [1, 2, 3] conf["foo.a"] = "bar" conf["foo.b"] = dict(bar=23) conf["foo.c"] = [1, 2, 3] assert conf.items() == other_dict.items() assert conf.values() == other_dict.values() assert conf.keys() == other_dict.keys() assert [x for x in conf] == other_dict.keys() assert all(x in conf for x in other_dict) assert all(conf[k] == v for k, v in other_dict.items()) assert all(conf.get(k) == v for k, v in other_dict.items()) assert conf.get("DOESNOTEXIST") is None assert conf.get("DOESNOTEXIST", "foo") == "foo" with pytest.raises(KeyError): conf["DOESNOTEXIST"] assert ObjectConfig(project).items() == other_dict.items() assert ObjectConfig(project).values() == other_dict.values() assert ObjectConfig(project).keys() == other_dict.keys() assert [x for x in ObjectConfig(project)] == other_dict.keys() assert all(x in ObjectConfig(project) for x in other_dict) assert all(ObjectConfig(project)[k] == v for k, v in other_dict.items()) assert all( ObjectConfig(project).get(k) == v for k, v in other_dict.items()) assert ObjectConfig(project).get("DOESNOTEXIST") is None assert ObjectConfig(project).get("DOESNOTEXIST", "foo") == "foo" with pytest.raises(KeyError): ObjectConfig(project)["DOESNOTEXIST"]