def test_items_are_pickable():
n = item(12)
s = pickle.dumps(n)
assert pickle.loads(s).as_string() == "12"
n = item(12.34)
s = pickle.dumps(n)
assert pickle.loads(s).as_string() == "12.34"
n = item(True)
s = pickle.dumps(n)
assert pickle.loads(s).as_string() == "true"
n = item(datetime(2018, 10, 11, 12, 34, 56, 123456))
s = pickle.dumps(n)
assert pickle.loads(s).as_string() == "2018-10-11T12:34:56.123456"
n = item(date(2018, 10, 11))
s = pickle.dumps(n)
assert pickle.loads(s).as_string() == "2018-10-11"
n = item(time(12, 34, 56, 123456))
s = pickle.dumps(n)
assert pickle.loads(s).as_string() == "12:34:56.123456"
n = item([1, 2, 3])
s = pickle.dumps(n)
assert pickle.loads(s).as_string() == "[1, 2, 3]"
n = item({"foo": "bar"})
s = pickle.dumps(n)
assert pickle.loads(s).as_string() == 'foo = "bar"\n'
n = inline_table()
n["foo"] = "bar"
s = pickle.dumps(n)
assert pickle.loads(s).as_string() == '{foo = "bar"}'
n = item("foo")
s = pickle.dumps(n)
assert pickle.loads(s).as_string() == '"foo"'
n = item([{"foo": "bar"}])
s = pickle.dumps(n)
assert pickle.loads(s).as_string() == 'foo = "bar"\n'
def test_tables_behave_like_dicts():
t = item({"foo": "bar"})
assert (
t.as_string()
== """foo = "bar"
"""
)
t.update({"bar": "baz"})
assert (
t.as_string()
== """foo = "bar"
bar = "baz"
"""
)
t.update({"bar": "boom"})
assert (
t.as_string()
== """foo = "bar"
bar = "boom"
"""
)
def test_table_copy():
table = item({"foo": "bar"})
table_copy = table.copy()
assert isinstance(table_copy, Table)
table["foo"] = "baz"
assert table_copy["foo"] == "bar"
assert table_copy.as_string() == 'foo = "bar"\n'
def test_item_array_of_dicts_converted_to_aot():
a = item({"foo": [{"bar": "baz"}]})
assert (
a.as_string()
== """[[foo]]
bar = "baz"
"""
)
def test_dicts_are_converted_to_tables():
t = item({"foo": {"bar": "baz"}})
assert (
t.as_string()
== """[foo]
bar = "baz"
"""
)
def test_trim_comments_when_building_inline_table():
table = inline_table()
row = parse('foo = "bar" # Comment')
table.update(row)
assert table.as_string() == '{foo = "bar"}'
value = item("foobaz")
value.comment("Another comment")
table.append("baz", value)
assert "# Another comment" not in table.as_string()
def test_dicts_with_sub_dicts_are_properly_converted():
t = item({"foo": {"bar": {"string": "baz"}, "int": 34, "float": 3.14}})
assert (t.as_string() == """[foo]
float = 3.14
int = 34
[foo.bar]
string = "baz"
""")
def test_array_multiline():
t = item([1, 2, 3, 4, 5, 6, 7, 8])
t.multiline(True)
expected = """\
[
1,
2,
3,
4,
5,
6,
7,
8,
]"""
assert expected == t.as_string()
t = item([])
assert "[]" == t.as_string()
def test_dicts_are_converted_to_tables_and_sorted():
t = item({"foo": {"bar": "baz", "abc": 123, "baz": [{"c": 3, "b": 2, "a": 1}]}})
assert (
t.as_string()
== """[foo]
abc = 123
bar = "baz"
[[foo.baz]]
a = 1
b = 2
c = 3
"""
)
def test_floats_behave_like_floats():
i = item(34.12)
assert i == 34.12
assert i.as_string() == "34.12"
i += 1
assert i == 35.12
assert i.as_string() == "35.12"
i -= 2
assert i == 33.12
assert i.as_string() == "33.12"
doc = parse("float = +34.12")
doc["float"] += 1
assert doc.as_string() == "float = +35.12"
def test_datetimes_behave_like_datetimes():
i = item(datetime(2018, 7, 22, 12, 34, 56))
assert i == datetime(2018, 7, 22, 12, 34, 56)
assert i.as_string() == "2018-07-22T12:34:56"
i += timedelta(days=1)
assert i == datetime(2018, 7, 23, 12, 34, 56)
assert i.as_string() == "2018-07-23T12:34:56"
i -= timedelta(days=2)
assert i == datetime(2018, 7, 21, 12, 34, 56)
assert i.as_string() == "2018-07-21T12:34:56"
doc = parse("dt = 2018-07-22T12:34:56-05:00")
doc["dt"] += timedelta(days=1)
assert doc.as_string() == "dt = 2018-07-23T12:34:56-05:00"
def test_dates_behave_like_dates():
i = item(date(2018, 7, 22))
assert i == date(2018, 7, 22)
assert i.as_string() == "2018-07-22"
i += timedelta(days=1)
assert i == datetime(2018, 7, 23)
assert i.as_string() == "2018-07-23"
i -= timedelta(days=2)
assert i == date(2018, 7, 21)
assert i.as_string() == "2018-07-21"
doc = parse("dt = 2018-07-22 # Comment")
doc["dt"] += timedelta(days=1)
assert doc.as_string() == "dt = 2018-07-23 # Comment"
def test_strings_behave_like_strs():
i = item("foo")
assert i == "foo"
assert i.as_string() == '"foo"'
i += " bar"
assert i == "foo bar"
assert i.as_string() == '"foo bar"'
i += " é"
assert i == "foo bar é"
assert i.as_string() == '"foo bar é"'
doc = parse('str = "foo" # Comment')
doc["str"] += " bar"
assert doc.as_string() == 'str = "foo bar" # Comment'
def test_integers_behave_like_ints():
i = item(34)
assert i == 34
assert i.as_string() == "34"
i += 1
assert i == 35
assert i.as_string() == "35"
i -= 2
assert i == 33
assert i.as_string() == "33"
doc = parse("int = +34")
doc["int"] += 1
assert doc.as_string() == "int = +35"
def test_array_behaves_like_a_list():
a = item([1, 2])
assert a == [1, 2]
assert a.as_string() == "[1, 2]"
a += [3, 4]
assert a == [1, 2, 3, 4]
assert a.as_string() == "[1, 2, 3, 4]"
del a[2]
assert a == [1, 2, 4]
assert a.as_string() == "[1, 2, 4]"
assert a.pop() == 4
assert a == [1, 2]
assert a.as_string() == "[1, 2]"
a[0] = 4
assert a == [4, 2]
a[-2] = 0
assert a == [0, 2]
del a[-2]
assert a == [2]
assert a.as_string() == "[2]"
a.clear()
assert a == []
assert a.as_string() == "[]"
content = """a = [1, 2,] # Comment
"""
doc = parse(content)
assert doc["a"] == [1, 2]
doc["a"] += [3, 4]
assert doc["a"] == [1, 2, 3, 4]
assert (
doc.as_string()
== """a = [1, 2, 3, 4] # Comment
"""
)
def test_dicts_are_converted_to_tables_and_keep_order():
t = item(
OrderedDict([(
"foo",
OrderedDict([
("bar", "baz"),
("abc", 123),
("baz", [OrderedDict([("c", 3), ("b", 2), ("a", 1)])]),
]),
)]))
assert (t.as_string() == """[foo]
bar = "baz"
abc = 123
[[foo.baz]]
c = 3
b = 2
a = 1
""")
def test_dicts_are_converted_to_tables_and_are_sorted_if_requested():
t = item(
OrderedDict([(
"foo",
OrderedDict([
("bar", "baz"),
("abc", 123),
("baz", [OrderedDict([("c", 3), ("b", 2), ("a", 1)])]),
]),
)]),
_sort_keys=True,
)
assert (t.as_string() == """[foo]
abc = 123
bar = "baz"
[[foo.baz]]
a = 1
b = 2
c = 3
""")
def test_array_behaves_like_a_list():
a = item([1, 2])
assert a == [1, 2]
assert a.as_string() == "[1, 2]"
a += [3, 4]
assert a == [1, 2, 3, 4]
assert a.as_string() == "[1, 2, 3, 4]"
del a[2]
assert a == [1, 2, 4]
assert a.as_string() == "[1, 2, 4]"
del a[-1]
assert a == [1, 2]
assert a.as_string() == "[1, 2]"
del a[-2]
assert a == [2]
assert a.as_string() == "[2]"
if not PY2:
a.clear()
assert a == []
assert a.as_string() == "[]"
content = """a = [1, 2] # Comment
"""
doc = parse(content)
assert doc["a"] == [1, 2]
doc["a"] += [3, 4]
assert doc["a"] == [1, 2, 3, 4]
assert (
doc.as_string()
== """a = [1, 2, 3, 4] # Comment
"""
)
def test_dicts_are_converted_to_tables_and_keep_order():
t = item(
{
"foo": {
"bar": "baz",
"abc": 123,
"baz": [{"c": 3, "b": 2, "a": 1}],
},
}
)
assert (
t.as_string()
== """[foo]
bar = "baz"
abc = 123
[[foo.baz]]
c = 3
b = 2
a = 1
"""
)
def test_tables_behave_like_dicts():
t = item({"foo": "bar"})
assert (
t.as_string()
== """foo = "bar"
"""
)
t.update({"bar": "baz"})
assert (
t.as_string()
== """foo = "bar"
bar = "baz"
"""
)
t.update({"bar": "boom"})
assert (
t.as_string()
== """foo = "bar"
bar = "boom"
"""
)
assert t.get("bar") == "boom"
assert t.setdefault("foobar", "fuzz") == "fuzz"
assert (
t.as_string()
== """foo = "bar"
bar = "boom"
foobar = "fuzz"
"""
)
def test_times_behave_like_times():
i = item(time(12, 34, 56))
assert i == time(12, 34, 56)
assert i.as_string() == "12:34:56"
def decompose(output, fill_descriptor_path, source, override):
logger.debug("Loading model from {}", source)
source = Path(source)
if output is None:
output = get_default_output_directory(source)
else:
output = Path(output)
output.mkdir(parents=True, exist_ok=True)
fill_descriptor = tk.document()
fill_descriptor.add(
tk.comment(f'This is a decomposition of "{source.name}" model'))
parse_result: ParseResult = from_file(source)
if parse_result.title:
fill_descriptor.append("title", parse_result.title)
model: Universe = parse_result.universe
if model.comment:
fill_descriptor.append("comment", model.comment)
named_transformations = list(collect_transformations(model))
fill_descriptor.append("created", item(datetime.now()))
fill_descriptor.add(tk.nl())
already_processed_universes = set()
for c in model:
fill = c.options.pop("FILL", None)
if fill:
universe = fill["universe"]
words = [f"FILL={universe.name()}"]
transform = fill.get("transform", None)
if transform:
words[0] = "*" + words[0]
words.append("(")
words.extend(transform.get_words())
words.append(")")
comm = c.options.get("comment", [])
comm.append("".join(words))
c.options["comment"] = comm
descriptor = tk.table()
universe_name = universe.name()
fn = f"u{universe_name}.i"
descriptor["universe"] = universe_name
if transform:
name = transform.name()
if name is None:
# The transformation is anonymous, so, store it's specification
# omitting redundant '*', TR0 words, and interleaving space tokens
descriptor["transform"] = tk.array(
transform.mcnp_words()[2:][1::2])
else:
descriptor["transform"] = name
descriptor["file"] = fn
fill_descriptor.append(str(c.name()), descriptor)
fill_descriptor.add(tk.nl())
if universe_name not in already_processed_universes:
move_universe_attribute_to_comments(universe)
save_mcnp(universe, output / fn, override)
logger.debug("The universe {} has been saved to {}",
universe_name, fn)
already_processed_universes.add(universe_name)
named_transformations_descriptor = tk.table()
named_transformations = sorted(named_transformations,
key=lambda x: x.name())
for t in named_transformations:
named_transformations_descriptor[f"tr{t.name()}"] = tk.array(
t.mcnp_words()[2:][1::2])
fill_descriptor.append("named_transformations",
named_transformations_descriptor)
fill_descriptor.add(tk.nl())
fdp = output / fill_descriptor_path
with open(fdp, "w") as fid:
res = tk.dumps(fill_descriptor)
fid.write(res)
logger.debug("Fill descriptor is saved in {}", fdp)
envelopes_path = output / "envelopes.i"
save_mcnp(model, envelopes_path, override)
logger.debug("The envelopes are saved to {}", envelopes_path)