def _init_from(self, method=None, **kwargs):
"""Initialize from easy-reading YAML or from JSON."""
filename = os.path.join(
self.directory, self.name + "." + method # error if None
)
# Create GraphTransliterator using factory
if method == "yaml":
gt = GraphTransliterator.from_yaml_file(filename, **kwargs)
elif method == "json":
with open(filename, "r") as f:
gt = GraphTransliterator.loads(f.read(), **kwargs)
# Select coverage superclass, if coverage set.
if kwargs.get("coverage"):
_super = CoverageTransliterator
else:
_super = GraphTransliterator
_super.__init__(
self,
gt._tokens,
gt._rules,
gt._whitespace,
onmatch_rules=gt._onmatch_rules,
metadata=gt._metadata,
ignore_errors=gt._ignore_errors,
check_ambiguity=kwargs.get("check_ambiguity", False),
onmatch_rules_lookup=gt._onmatch_rules_lookup,
tokens_by_class=gt._tokens_by_class,
graph=gt._graph,
tokenizer_pattern=gt._tokenizer_pattern,
graphtransliterator_version=gt._graphtransliterator_version,
coverage=kwargs.get("coverage", True),
)
def test_serialization():
"""Test serialization of graphtransliterator"""
# Field definitions
required_fields = ["tokens", "rules", "whitespace"]
optional_fields = [
"onmatch_rules",
"metadata",
"ignore_errors",
"onmatch_rules_lookup",
"tokens_by_class",
"graph",
"tokenizer_pattern",
"graphtransliterator_version",
]
ordered_fields = required_fields + optional_fields
yaml_ = """
tokens:
a: [vowel]
' ': [wb]
rules:
a: A
' ': ' '
whitespace:
default: " "
consolidate: false
token_class: wb
onmatch_rules:
- <vowel> + <vowel>: ',' # add a comma between vowels
metadata:
author: "Author McAuthorson"
"""
gt = GraphTransliterator.from_yaml(yaml_)
# test dump
dump = gt.dump()
assert dump["graph"]["edge"]
# test ordering of dump fields
assert list(dump.keys()) == ordered_fields
# test dump version
assert dump[
"graphtransliterator_version"] == graphtransliterator.__version__
assert re.match(r"\d+\.\d+\.\d+$",
gt.dump()["graphtransliterator_version"])
# test dumps
x = gt.dumps()
assert "graph" in gt.dumps()
assert type(x) == str
# test loads
new_gt = GraphTransliterator.loads(x)
assert GraphTransliterator.loads(gt.dumps()).dumps()
assert type(new_gt) == GraphTransliterator
# test load
settings = gt.dump()
assert type(GraphTransliterator.load(settings)) == GraphTransliterator
# confirm settings not affected by load
assert settings == settings
# confirm compacting (dropping) optional settings works
for length in range(1, len(optional_fields)):
for to_drop in combinations(optional_fields, length):
settings = gt.dump()
for _ in to_drop:
settings.pop(_)
if settings.get("onmatch_rules_lookup"
) and not settings.get("onmatch_rules"):
with pytest.raises(ValidationError):
assert GraphTransliterator.load(settings)
else:
assert GraphTransliterator.load(settings)
# test IncorrectVersionException
_ = gt.dump()
_['graphtransliterator_version'] += "1" # add 1 e.g. 1.0.11
with pytest.raises(IncorrectVersionException):
assert GraphTransliterator.load(_)