def test_combination(self): k = "The format {is} {valid} {while} some of the args are invalid" res, _ = get_keywords_between_braces(k) self.assertEqual(1, len(res)) self.assertFalse("is" in res) self.assertTrue("valid" in res) self.assertFalse("while" in res)
def resolve_with_resolved_values(self, **resolved_values): s1 = set(self.kwargs.keys()) actual_keys, _ = get_keywords_between_braces(self._format) if s1 != actual_keys: diff = (actual_keys - s1).union(s1 - actual_keys) raise Exception( "The format for the string builder has changed since runtime, or an internal error has" " occurred. The following keys did not appear in both sets: " + ", ".join(diff)) s2 = set(resolved_values.keys()) missing_keys = s1 - s2 if len(missing_keys) > 0: raise IncorrectArgsException( "There were missing parameters when formatting string: " + ", ".join(missing_keys)) unresolved_values = [ f"{r} ({type(resolved_values[r]).__name__})" for r in resolved_values if not any( isinstance(resolved_values[r], t) for t in StringFormatter.resolved_types) ] if len(unresolved_values) > 0: raise ValueError( "There were unresolved parameters when formatting string: " + ", ".join(unresolved_values)) retval = self._format for k in resolved_values: retval = retval.replace(f"{{{k}}}", str(resolved_values[k])) return retval
def __init__(self, format: str, **kwargs): self._format: str = format keywords, balance = get_keywords_between_braces(self._format) if balance > 0: Logger.warn( "There was an imbalance of braces in the string _format, this might cause issues with concatenation" ) skwargs = set(kwargs.keys()) if not keywords == skwargs: # what's the differences if not keywords.issubset(skwargs): raise IncorrectArgsException( "The _format required additional arguments to be provided by " "**kwargs, requires the keys:" + ", ".join(keywords - skwargs)) else: raise TooManyArgsException( "The **kwargs contained unrecognised keys: " + ", ".join(skwargs - keywords)) self.kwargs = kwargs
def _create_new_formatter_from_strings_and_args(strings: [str], **kwargs): new_format = "".join(strings) try: return StringFormatter(new_format, **kwargs) except IncorrectArgsException as e: new_params = set( get_keywords_between_braces(new_format)[0] - set(kwargs.keys())) raise InvalidByProductException( "Joining the input files (to '{new_format}') created the new params: " + ", ".join(new_params))
def __add__(self, other): from janis_core.operators.selectors import InputSelector if isinstance(other, str): # check if it has args in it keywords = get_keywords_between_braces(other) if len(keywords) > 0: invalidkwargs = [ k for k in self.kwargs if k not in self.kwargs ] if len(invalidkwargs) > 0: raise InvalidByProductException( f"The string to be concatenated contained placeholder(s) ({', '.join(invalidkwargs)})" f"that were not in the original StringFormatter") return self._create_new_formatter_from_strings_and_args( [self._format, other], **self.kwargs) elif isinstance(other, InputSelector): return self + other.to_string_formatter() elif isinstance(other, StringFormatter): # check if args overlap and they're different s1 = set(self.kwargs.keys()) s2 = set(other.kwargs.keys()) intersection = s1.intersection(s2) if len(intersection) > 0: not_same_args = [ k for k in intersection if self.kwargs[k] != other.kwargs[k] ] if len(not_same_args) > 0: raise ConflictingArgumentsException( f"Couldn't concatenate formats as there keys ({', '.join(not_same_args)}) " f"that were not equal between formatters ") # yeah we sweet new_args = {**self.kwargs, **other.kwargs} return StringFormatter._create_new_formatter_from_strings_and_args( [self._format, other._format], **new_args)
def test_invalid_2(self): k = "test {while}" res, _ = get_keywords_between_braces(k) self.assertEqual(0, len(res)) self.assertFalse("while" in res)
def test_valid_3(self): k = "test {X123}" res, _ = get_keywords_between_braces(k) self.assertEqual(1, len(res)) self.assertTrue("X123" in res)
def test_unwrap_first_group(self): k = "theres } the wrong bracket {first}" res, _ = get_keywords_between_braces(k) self.assertEqual(1, len(res)) self.assertSetEqual({"first"}, res)
def test_nested_group(self): k = "theres {a nested {group} here} but not just {that}" res, _ = get_keywords_between_braces(k) self.assertEqual(1, len(res)) self.assertSetEqual({"that"}, res)
def test_two_groups(self): k = "there's {one} matches {here}" res, _ = get_keywords_between_braces(k) self.assertEqual(2, len(res)) self.assertSetEqual({"one", "here"}, res)
def test_one_group(self): k = "there's {one} match here" res, _ = get_keywords_between_braces(k) self.assertEqual(1, len(res)) self.assertSetEqual({"one"}, res)
def test_no_group(self): k = "there's no match here" res, _ = get_keywords_between_braces(k) self.assertEqual(0, len(res))