def __init__(self, *args, **kw):
# type: (Any, Any) -> None
if hasattr(self, '_od'):
raise_immutable(self)
try:
self._od = ordereddict(*args, **kw)
except TypeError:
if PY2:
self._od = ordereddict(args[0].items())
else:
raise
def case_4():
""""""
global_env = ordereddict()
global_env["A"] = "0"
step_env = ordereddict()
step_env["A"] = "1$<A>"
expected_step_env = ordereddict()
expected_step_env['A'] = '10'
expected_global_env_size = 1
return step_env, global_env, expected_step_env, expected_global_env_size
def default_roles(self) -> Dict[Text, Any]:
"""Dictionary of default Rasa X roles.
Preserves key order when dumped to yaml.
"""
return ordereddict(DEFAULT_ROLES)
def get_tabs(skconf):
"""Return a list of tab names determined from scikick.yml
skconf -- ScikickConfig object
"""
# Start with analysis keys
exes = skconf.exes
# Remove index from menu building
if len(skconf.index_exes) == 1:
exes.remove(skconf.index_exes[0])
# If empty or homepage only, exit
if len(exes) == 0:
return {}
# Find common directory
nb_root = os.path.commonpath(list(exes))
# Then build menus accoring to exes order
tabs = ordereddict()
for exe in exes:
tabname = os.path.normpath(rm_commdir(os.path.dirname(exe), nb_root))
# Add unique tabs for each exe at nb_root
if tabname == ".":
out_base = skconf.get_info(exe, "out_base")
assert not os.path.isdir(out_base)
tabname = os.path.basename(out_base)
# Add menus for the rest
if tabname not in tabs.keys():
tabs[tabname] = []
# Add exe to respective tabs
tabs[tabname].append(os.path.splitext(exe)[0])
return tabs
def construct_yaml_omap(self, node):
# Note: we do now check for duplicate keys
omap = ordereddict()
yield omap
if not isinstance(node, SequenceNode):
raise ConstructorError(
"while constructing an ordered map", node.start_mark,
"expected a sequence, but found %s" % node.id, node.start_mark)
for subnode in node.value:
if not isinstance(subnode, MappingNode):
raise ConstructorError(
"while constructing an ordered map", node.start_mark,
"expected a mapping of length 1, but found %s" %
subnode.id,
subnode.start_mark)
if len(subnode.value) != 1:
raise ConstructorError(
"while constructing an ordered map", node.start_mark,
"expected a single mapping item, but found %d items" %
len(subnode.value),
subnode.start_mark)
key_node, value_node = subnode.value[0]
key = self.construct_object(key_node)
assert key not in omap
value = self.construct_object(value_node)
omap[key] = value
def test_load_fobj_with_include_recursive_merge():
"""
--- test.yaml ---
thing:
value: 4
<<<:
thing:
additional: 6
!recursive_merge :
thing:
yet_another_recursive_merge: true
<<<: !include test_simple_mapping.yaml
--- stuff.yaml ---
otherthings:
myval: 45
"""
expected = {
"thing": {
"value": 4,
"additional": 6,
"yet_another_recursive_merge": True,
},
"otherthings": ordereddict([("myval", 45)]),
}
fpath = resource_filename(TESTPKG,
"data/test_include_recursive_merge.yaml")
with open(fpath, "r") as fobj:
o = yaml_overlay.load(fobj)
assert o == expected
def construct_yaml_omap(self, node):
# Note: we do now check for duplicate keys
omap = ordereddict()
yield omap
if not isinstance(node, SequenceNode):
raise ConstructorError(
"while constructing an ordered map", node.start_mark,
"expected a sequence, but found %s" % node.id, node.start_mark)
for subnode in node.value:
if not isinstance(subnode, MappingNode):
raise ConstructorError(
"while constructing an ordered map", node.start_mark,
"expected a mapping of length 1, but found %s" %
subnode.id,
subnode.start_mark)
if len(subnode.value) != 1:
raise ConstructorError(
"while constructing an ordered map", node.start_mark,
"expected a single mapping item, but found %d items" %
len(subnode.value),
subnode.start_mark)
key_node, value_node = subnode.value[0]
key = self.construct_object(key_node)
assert key not in omap
value = self.construct_object(value_node)
omap[key] = value
def sk_mv(args):
"""Rename an Rmd in scikick.yml and associated files"""
config = yaml_in(need_pages=True)
# multiple args
src = [os.path.normpath(p) for p in args.src]
# only a single arg
dest = [os.path.normpath(p) for p in args.dest]
#check if src and dest are valid
sk_move_check(src, dest)
# save the (src, dest) pairs (to be used with moves in scikick.yml)
(new_src, new_dest) = sk_move_prepare_src_dest(src, dest)
new_src = list(map(os.path.normpath, new_src))
new_dest = list(map(os.path.normpath, new_dest))
# leave only unique pairs of (src, dest) files
mv_dict = ordereddict()
for k in new_src:
i = new_src.index(k)
mv_dict[new_src[i]] = new_dest[i]
# perform the move operation (using the initial args)
for s in src:
git_retcode = 0
if args.git:
print(f"sk: git mv {s} {dest[0]}")
git_res = subprocess.run(f"git mv {s} {dest[0]}", shell=True, \
stderr=subprocess.PIPE)
git_retcode = git_res.returncode
if git_retcode != 0:
warn("sk: Warning: Git returned an error:")
warn(git_res.stderr.decode().strip())
warn("sk: Warning: Falling back to mv")
if (git_retcode != 0) or (not args.git):
print(f"sk: mv {s} {dest[0]}")
shutil.move(s, dest[0])
sk_move_extras(mv_dict)
def case_2():
"""Variable to expand are spread across ``step_env`` and ``global_env``.
"""
global_env = ordereddict()
global_env['B'] = '$<A>'
step_env = ordereddict()
step_env['C'] = '$<B>'
step_env['A'] = 'Hello'
expected_step_env = ordereddict()
expected_step_env['C'] = 'Hello'
expected_step_env['A'] = 'Hello'
expected_global_env_size = 3
return step_env, global_env, expected_step_env, expected_global_env_size
def write_to_file(repository, filename, check_type=True):
if type(repository) == dict:
repository = ordereddict(sorted(repository.items(),
key=lambda t: t[0]))
repository = ruamel.yaml.comments.CommentedMap(repository)
output_str = prettier(repository, check_type)
with open(filename, mode="w") as output_file:
output_file.write(output_str)
def merge_valuefile(source, new):
source = ruamel_yaml_load(source)
if not source:
source = ordereddict()
new = ruamel_yaml_load(new)
dpath.util.merge(source, new)
return ruamel_yaml_dump(source)
def test_load_ordered_map():
data = "mymap: !!omap\n- a: 1\n- b: 2\n- c: 3\n- d: 4\n- e: 5\n"
expected = {
"mymap": ordereddict(
[("a", 1), ("b", 2), ("c", 3), ("d", 4), ("e", 5)]
)
}
o = yaml_overlay.load(data)
assert o == expected
def test_omap_out(self):
# ordereddict mapped to !!omap
x = ordereddict([('a', 1), ('b', 2)])
res = ruamel.yaml.dump(x, default_flow_style=False)
assert res == dedent("""
!!omap
- a: 1
- b: 2
""")
def case_1():
"""All variables to expand are in ``step_env``
"""
global_env = ordereddict()
step_env = ordereddict()
step_env['C'] = '$<B>'
step_env['B'] = '$<A>'
step_env['A'] = 'Hello'
expected_step_env = ordereddict()
expected_step_env['C'] = 'Hello'
expected_step_env['B'] = 'Hello'
expected_step_env['A'] = 'Hello'
expected_global_env_size = 3
return step_env, global_env, expected_step_env, expected_global_env_size
def test_load_sheet():
"""Test right theme, subtheme, sheet name return the right data."""
d = load_sheet('algebra', 'expand', 'double')
assert isinstance(d, OrderedDict)
assert isinstance(d, ordereddict)
assert isinstance(d, CommentedOrderedMap)
assert d == ordereddict([
('title',
'Algebra: expand and reduce double brackets'),
('exercise',
ordereddict([('details_level', 'medium'),
('text_exc',
'Expand and reduce the following '
'expressions:'),
('text_ans', 'Example of solutions:'),
('questions',
'expand double -> intpairs_2to9;;intpairs_2to9 (5)')
]))])
def default_environments_config_local(
rasa_port: Union[int, Text]) -> Dict[Text, Any]:
stack_config = ordereddict([
(
RASA_PRODUCTION_ENVIRONMENT,
ordereddict([
("url", "http://localhost:{}".format(str(rasa_port))),
("token", config.rasa_token),
]),
),
(
"worker",
ordereddict([
("url", "http://localhost:{}".format(str(rasa_port))),
("token", config.rasa_token),
]),
),
])
return {"environments": ordereddict([("rasa", stack_config)])}
def yaml_in(ymlpath='scikick.yml', need_pages=False):
"""Read scikick.yml.
Returns an ordereddict.
need_pages -- logical, whether to error if analysis is empty
"""
#Exit with an error message if scikick.yml is not found
if not os.path.isfile(ymlpath):
reterr(f"sk: Error: {ymlpath} not found," + \
"to get a template, run\nsk: sk init")
ymli = yaml.YAML()
ymli = ymli.load(open(ymlpath, "r"))
if ymli is None:
warn("sk: Warning: scikick.yml is empty")
ymli = dict()
## Checks that will be modified for this read-in only
# make sure that mandatory fields are present
if "analysis" not in ymli.keys():
if need_pages:
reterr("sk: Error: no pages have been added to scikick.yml, " + \
"this can be done with\nsk: sk add my.rmd")
else:
warn("sk: Warning: scikick.yml is missing analysis field")
ymli["analysis"] = ordereddict()
else:
if ymli["analysis"] is None:
ymli["analysis"] = ordereddict()
if len(ymli["analysis"]) == 0:
if need_pages:
reterr("sk: Error: no pages have been added to scikick.yml, " + \
"this can be done with\nsk: sk add my.rmd")
else:
ymli["analysis"] = ordereddict()
if "reportdir" not in ymli.keys():
warn("sk: Warning: scikick.yml is missing reportdir field")
ymli["reportdir"] = ""
return ymli
def test_omap_out(self):
# ordereddict mapped to !!omap
from ruamel.yaml.compat import ordereddict
import ruamel.yaml # NOQA
x = ordereddict([('a', 1), ('b', 2)])
res = round_trip_dump(x, default_flow_style=False)
assert res == dedent("""
!!omap
- a: 1
- b: 2
""")
def test_dump_ruamel_ordereddict(self):
from ruamel.ordereddict import ordereddict
# OrderedDict mapped to !!omap
x = ordereddict([('a', 1), ('b', 2)])
res = ruamel.yaml.dump(x,
Dumper=ruamel.yaml.RoundTripDumper,
default_flow_style=False)
assert res == dedent("""
!!omap
- a: 1
- b: 2
""")
def case_3():
"""Variable to expand are spread across ``step_env`` and ``global_env``
with one of ``step_env`` variable that can not be expanded.
"""
global_env = ordereddict()
global_env['D'] = '$<C>'
global_env['C'] = 'Ciao'
global_env['G'] = '$<F>'
step_env = ordereddict()
step_env['H'] = '$<G>'
step_env['E'] = '$<D>'
step_env['B'] = '$<A>'
step_env['A'] = 'Hello'
expected_step_env = ordereddict()
expected_step_env['H'] = '$<F>'
expected_step_env['E'] = 'Ciao'
expected_step_env['B'] = 'Hello'
expected_step_env['A'] = 'Hello'
expected_global_env_size = 7
return step_env, global_env, expected_step_env, expected_global_env_size
def default_stack_config() -> Dict[Text, Union[Text, List[Dict[Text, Text]]]]:
policies = [
{
"name": "MemoizationPolicy"
},
{
"name": "KerasPolicy"
},
{
"name": "MappingPolicy"
},
]
return ordereddict([
("pipeline", "supervised_embeddings"),
("language", "en"),
("policies", policies),
])
def reordered_analysis(tabs, skconf, order):
"""Reorder the 'analysis' dict in scikick.yml according to the ordering of
the directories output by get_tabs.
Returns the reordered 'analysis' dict which produces
the differently ordered tab list in all pages
tabs -- list of tab names
skconf -- ScikickConfig object
order -- list of indices for tabs
"""
new_analysis = ordereddict()
for ord_no in order:
# Add each exe dict entry to new dict
for out_base in tabs[list(tabs.keys())[ord_no]]:
norm_rmd = os.path.normpath(out_base)
curr_key = list(filter(lambda x: \
os.path.splitext(x)[0] == norm_rmd, \
skconf.analysis.keys()))[0]
new_analysis[curr_key] = skconf.analysis[curr_key]
return new_analysis
def test_map(self):
from ruamel.yaml.compat import ordereddict
from ruamel.yaml.comments import CommentedMap
from ruamel.yaml.scalarstring import walk_tree, preserve_literal
from ruamel.yaml.scalarstring import DoubleQuotedScalarString as dq
from ruamel.yaml.scalarstring import SingleQuotedScalarString as sq
data = CommentedMap()
data[1] = 'a'
data[2] = 'with\nnew : line\n'
data[3] = '${abc}'
data[4] = 'almost:mapping'
m = ordereddict([('\n', preserve_literal), ('${', sq), (':', dq)])
walk_tree(data, map=m)
exp = """\
1: a
2: |
with
new : line
3: '${abc}'
4: "almost:mapping"
"""
assert round_trip_dump(data) == dedent(exp)
def __init__(self, *args, **kw):
# type: (Any, Any) -> None
self._od = ordereddict(*args, **kw)
def __init__(self, values=None):
# type: (Any) -> None
self.odict = ordereddict()
MutableSet.__init__(self)
if values is not None:
self |= values # type: ignore
def __init__(self, values=None):
self.odict = ordereddict()
MutableSet.__init__(self)
if values is not None:
self |= values
def write_to_string(repository, check_type=True):
if type(repository) == dict:
repository = ordereddict(sorted(repository.items(),
key=lambda t: t[0]))
repository = ruamel.yaml.comments.CommentedMap(repository)
return prettier(repository, check_type)
def __init__(self, values=None):
self.odict = ordereddict()
MutableSet.__init__(self)
if values is not None:
self |= values
