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 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)