input
stringlengths 11
5.29k
| target
stringlengths 20
8.26k
|
|---|---|
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def active_at_datetime(self, deadline):
"""Check whether the verification was active at a particular datetime.
Arguments:
deadline (datetime): The date at which the verification was active
(created before and expiration datetime is after today).
Returns:
bool
"""
return (
self.created_at < deadline and
self.expiration_datetime > now()
) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def unbind(self):
return True |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def serialize(self, value, display=False):
"""Convert value back to string for saving."""
if value is None:
return ""
return str(value) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def deserialize(self, value):
value = decode(value).strip()
validators.validate_required(value, self._required)
if not value:
return None
validators.validate_choice(value, self._choices)
return value |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def deserialize(self, value):
value = decode(value)
validators.validate_required(value, self._required)
if not value:
return None
if value.lower() in self.true_values:
return True
elif value.lower() in self.false_values:
return False
raise ValueError(f"invalid value for boolean: {value!r}") |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def serialize(self, value, display=False):
if value is True:
return "true"
elif value in (False, None):
return "false"
else:
raise ValueError(f"{value!r} is not a boolean") |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def serialize(self, value, display=False):
lookup = {v: k for k, v in self.levels.items()}
if value in lookup:
return encode(lookup[value])
return "" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def check_prereq(self, prereqMode = 0):
self._exit_modes_beyond(prereqMode)
if len(self.modeList) <= prereqMode:
raise Exception("Attempted to enter menu when prerequist mode was not entered, expected: %d" % prereqMode) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def device_port(self):
if self._values['device_port'] is None:
return None
return int(self._values['device_port']) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def compare(self, param):
try:
result = getattr(self, param)
return result
except AttributeError:
return self.__default(param) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def modelDeselect(self, document: DocT):
"""A strand is selected based on whether its low or high endpoints
are selected. this value is a tuple ``(is_low, is_high)`` of booleans
"""
strand = self._strand_item.strand()
test = document.isModelStrandSelected(strand)
low_val, high_val = document.getSelectedStrandValue(strand) if test else (False, False)
if self.cap_type == 'low':
out_value = (False, high_val)
else:
out_value = (low_val, False)
if not out_value[0] and not out_value[1] and test:
document.removeStrandFromSelection(strand)
elif out_value[0] or out_value[1]:
document.addStrandToSelection(strand, out_value)
self.restoreParent() |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def modelSelect(self, document: DocT):
"""A strand is selected based on whether its low or high endpoints
are selected. this value is a tuple ``(is_low, is_high)`` of booleans
"""
strand = self._strand_item.strand()
test = document.isModelStrandSelected(strand)
low_val, high_val = document.getSelectedStrandValue(strand) if test else (False, False)
if self.cap_type == 'low':
out_value = (True, high_val)
else:
out_value = (low_val, True)
self.setSelected(True)
self.setSelectedColor(True)
document.addStrandToSelection(strand, out_value) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _eval_is_positive(self):
if self.args[0].is_extended_real:
return self.args[0].is_positive |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _eval_is_negative(self):
if self.args[0].is_extended_real:
return self.args[0].is_negative |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _eval_is_finite(self):
arg = self.args[0]
return arg.is_finite |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _eval_is_zero(self):
arg = self.args[0]
if arg.is_zero:
return True |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def exists(results, _name):
''' Check to see if the results include the name '''
if not results:
return False
if Utils.find_result(results, _name):
return True
return False |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def exists_env_value(self, key, value):
''' return whether a key, value pair exists '''
results = self.get_env_vars()
if not results:
return False
for result in results:
if result['name'] == key and result['value'] == value:
return True
return False |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def exists_env_key(self, key):
''' return whether a key, value pair exists '''
results = self.get_env_vars()
if not results:
return False
for result in results:
if result['name'] == key:
return True
return False |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def exists_volume(self, volume):
''' return whether a volume exists '''
exist_volumes = self.get_volumes()
volume_found = False
for exist_volume in exist_volumes:
if exist_volume['name'] == volume['name']:
volume_found = True
break
return volume_found |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def update_volume(self, volume):
'''place an env in the env var list'''
exist_volumes = self.get_volumes()
if not volume:
return False
# update the volume
update_idx = None
for idx, exist_vol in enumerate(exist_volumes):
if exist_vol['name'] == volume['name']:
update_idx = idx
break
if update_idx != None:
exist_volumes[update_idx] = volume
else:
self.add_volume(volume)
return True |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def needs_update_volume(self, volume, volume_mount):
''' verify a volume update is needed '''
exist_volume = self.find_volume_by_name(volume)
exist_volume_mount = self.find_volume_by_name(volume, mounts=True)
results = []
results.append(exist_volume['name'] == volume['name'])
if 'secret' in volume:
results.append('secret' in exist_volume)
results.append(exist_volume['secret']['secretName'] == volume['secret']['secretName'])
results.append(exist_volume_mount['name'] == volume_mount['name'])
results.append(exist_volume_mount['mountPath'] == volume_mount['mountPath'])
elif 'emptyDir' in volume:
results.append(exist_volume_mount['name'] == volume['name'])
results.append(exist_volume_mount['mountPath'] == volume_mount['mountPath'])
elif 'persistentVolumeClaim' in volume:
pvc = 'persistentVolumeClaim'
results.append(pvc in exist_volume)
if results[-1]:
results.append(exist_volume[pvc]['claimName'] == volume[pvc]['claimName'])
if 'claimSize' in volume[pvc]:
results.append(exist_volume[pvc]['claimSize'] == volume[pvc]['claimSize'])
elif 'hostpath' in volume:
results.append('hostPath' in exist_volume)
results.append(exist_volume['hostPath']['path'] == volume_mount['mountPath'])
return not all(results) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def is_added(self, requirement):
return requirement in self._requirements |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __contains__(self, requirement):
return self.is_added(requirement) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_can_write_simple_identifier(self):
escaped = cypher_escape("foo")
assert escaped == "foo" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_can_write_identifier_with_odd_chars(self):
escaped = cypher_escape("foo bar")
assert escaped == "`foo bar`" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_can_write_identifier_containing_back_ticks(self):
escaped = cypher_escape("foo `bar`")
assert escaped == "`foo ``bar```" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_zero(self):
encoded = cypher_repr(0)
assert encoded == u"0" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_positive_integer(self):
encoded = cypher_repr(123)
assert encoded == u"123" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_negative_integer(self):
encoded = cypher_repr(-123)
assert encoded == u"-123" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_positive_float(self):
encoded = cypher_repr(123.456)
assert encoded == u"123.456" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_negative_float(self):
encoded = cypher_repr(-123.456)
assert encoded == u"-123.456" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_bytes(self):
encoded = cypher_repr(b"hello, world")
assert encoded == u"'hello, world'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_unicode(self):
encoded = cypher_repr(u"hello, world")
assert encoded == u"'hello, world'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_bytes_with_escaped_chars(self):
encoded = cypher_repr(b"hello, 'world'", quote=u"'")
assert encoded == u"'hello, \\'world\\''" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_unicode_with_escaped_chars(self):
encoded = cypher_repr(u"hello, 'world'", quote=u"'")
assert encoded == u"'hello, \\'world\\''" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_empty_string(self):
encoded = cypher_repr(u"")
assert encoded == u"''" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_bell(self):
encoded = cypher_repr(u"\a")
assert encoded == u"'\\u0007'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_backspace(self):
encoded = cypher_repr(u"\b")
assert encoded == u"'\\b'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_form_feed(self):
encoded = cypher_repr(u"\f")
assert encoded == u"'\\f'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_new_line(self):
encoded = cypher_repr(u"\n")
assert encoded == u"'\\n'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_carriage_return(self):
encoded = cypher_repr(u"\r")
assert encoded == u"'\\r'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_horizontal_tab(self):
encoded = cypher_repr(u"\t")
assert encoded == u"'\\t'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_double_quote_when_single_quoted(self):
encoded = cypher_repr(u"\"")
assert encoded == u"'\"'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_single_quote_when_single_quoted(self):
encoded = cypher_repr(u"'", quote=u"'")
assert encoded == u"'\\''" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_double_quote_when_double_quoted(self):
encoded = cypher_repr(u"\"", quote=u"\"")
assert encoded == u'"\\""' |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_single_quote_when_double_quoted(self):
encoded = cypher_repr(u"'", quote=u"\"")
assert encoded == u'"\'"' |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_2_byte_extended_character(self):
encoded = cypher_repr(u"\xAB")
assert encoded == u"'\\u00ab'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_4_byte_extended_character(self):
encoded = cypher_repr(u"\uABCD")
assert encoded == u"'\\uabcd'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_8_byte_extended_character(self):
encoded = cypher_repr(u"\U0010ABCD")
assert encoded == u"'\\U0010abcd'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_complex_sequence(self):
encoded = cypher_repr(u"' '' '''")
assert encoded == u"\"' '' '''\"" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_list(self):
encoded = cypher_repr([1, 2.0, u"three"])
assert encoded == u"[1, 2.0, 'three']" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_empty_list(self):
encoded = cypher_repr([])
assert encoded == u"[]" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_should_encode_empty_map(self):
encoded = cypher_repr({})
assert encoded == u"{}" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def gettext(self, text: str, lang: str = None):
"""
Singular translations
"""
if lang is None:
lang = self.context_lang.get()
if lang not in self.translations:
return text
translator = self.translations[lang]
return translator.gettext(text) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def ngettext(self, singular: str, plural: str, lang: str = None, n=1):
"""
Plural translations
"""
if lang is None:
lang = self.context_lang.get()
if lang not in self.translations:
if n == 1:
return singular
return plural
translator = self.translations[lang]
return translator.ngettext(singular, plural, n) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def lazy_gettext(self, text: str, lang: str = None):
if not babel_imported:
raise RuntimeError('babel module is not imported. Check that you installed it.')
return LazyProxy(self.gettext, text, lang, enable_cache=False) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def lazy_ngettext(self, singular: str, plural: str, lang: str = None, n=1):
if not babel_imported:
raise RuntimeError('babel module is not imported. Check that you installed it.')
return LazyProxy(self.ngettext, singular, plural, lang, n, enable_cache=False) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def test_parse_statements():
parsed_statement = mariofile.parse_statements(STRING_PARSE_STATEMENTS.splitlines())
assert '\n'.join(parsed_statement) == "statement\nstatement con commento" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _rematcher(regex):
"""compile the regexp with the best available regexp engine and return a
matcher function"""
m = util.re.compile(regex)
try:
# slightly faster, provided by facebook's re2 bindings
return m.test_match
except AttributeError:
return m.match |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _compiledpats(self):
pat, matchfunc = _buildregexmatch(self._kindpats, "")
return matchfunc |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _compileddirpats(self):
pat, matchfunc = _buildregexmatch(
[("glob", p, "") for p in self._globdirpats], "$"
)
return matchfunc |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _remainingpats(pat, prefix):
"""list of patterns with prefix stripped
>>> _remainingpats("a/b/c", "")
['a/b/c']
>>> _remainingpats("a/b/c", "a")
['b/c']
>>> _remainingpats("a/b/c", "a/b")
['c']
>>> _remainingpats("a/b/c", "a/b/c")
[]
>>> _remainingpats("", "")
[]
"""
if prefix:
if prefix == pat:
return []
else:
assert pat[len(prefix)] == "/"
return [pat[len(prefix) + 1 :]]
else:
if pat:
return [pat]
else:
return [] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _convertretoglobs(repat):
"""Attempt to convert a regular expression pattern to glob patterns.
A single regular expression pattern might be converted into multiple
glob patterns.
Return None if conversion is unsupported.
>>> _convertretoglobs("abc*") is None
True
>>> _convertretoglobs("xx/yy/(?!zz/kk)")
['xx/yy/**', '!xx/yy/zz/kk/**']
>>> _convertretoglobs("x/y/(?:.*/)?BUCK")
['x/y/**/BUCK']
"""
m = _repat1.match(repat)
if m:
prefix, excluded = m.groups()
return ["%s/**" % prefix, "!%s/%s/**" % (prefix, excluded)]
m = _repat2.match(repat)
if m:
prefix, name = m.groups()
return ["%s/**/%s" % (prefix, name)]
return None |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __repr__(self):
return "<patternmatcher patterns=%r>" % self._pats |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __repr__(self):
return "<subdirmatcher path=%r, matcher=%r>" % (self._path, self._matcher) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __repr__(self):
return "<unionmatcher matchers=%r>" % self._matchers |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __repr__(self):
return "<xormatcher matchers=%r>" % self._matchers |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _patsplit(pattern, default):
"""Split a string into the optional pattern kind prefix and the actual
pattern."""
if ":" in pattern:
kind, pat = pattern.split(":", 1)
if kind in allpatternkinds:
return kind, pat
return default, pattern |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def peek():
return i < n and pat[i : i + 1] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _regex(kind, pat, globsuffix):
"""Convert a (normalized) pattern of any kind into a regular expression.
globsuffix is appended to the regexp of globs."""
if not pat and kind in ("glob", "relpath"):
return ""
if kind == "re":
return pat
if kind in ("path", "relpath"):
if pat == ".":
return ""
return util.re.escape(pat) + "(?:/|$)"
if kind == "rootfilesin":
if pat == ".":
escaped = ""
else:
# Pattern is a directory name.
escaped = util.re.escape(pat) + "/"
# Anything after the pattern must be a non-directory.
return escaped + "[^/]+$"
if kind == "relglob":
return "(?:|.*/)" + _globre(pat) + globsuffix
if kind == "relre":
if pat.startswith("^"):
return pat
return ".*" + pat
return _globre(pat) + globsuffix |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _buildregexmatch(kindpats, globsuffix):
"""Build a match function from a list of kinds and kindpats,
return regexp string and a matcher function."""
try:
regex = "(?:%s)" % "|".join(
[_regex(k, p, globsuffix) for (k, p, s) in kindpats]
)
if len(regex) > 20000:
raise OverflowError
return regex, _rematcher(regex)
except OverflowError:
# We're using a Python with a tiny regex engine and we
# made it explode, so we'll divide the pattern list in two
# until it works
l = len(kindpats)
if l < 2:
raise
regexa, a = _buildregexmatch(kindpats[: l // 2], globsuffix)
regexb, b = _buildregexmatch(kindpats[l // 2 :], globsuffix)
return regex, lambda s: a(s) or b(s)
except re.error:
for k, p, s in kindpats:
try:
_rematcher("(?:%s)" % _regex(k, p, globsuffix))
except re.error:
if s:
raise error.Abort(_("%s: invalid pattern (%s): %s") % (s, k, p))
else:
raise error.Abort(_("invalid pattern (%s): %s") % (k, p))
raise error.Abort(_("invalid pattern")) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def readpatternfile(filepath, warn, sourceinfo=False):
"""parse a pattern file, returning a list of
patterns. These patterns should be given to compile()
to be validated and converted into a match function.
trailing white space is dropped.
the escape character is backslash.
comments start with #.
empty lines are skipped.
lines can be of the following formats:
syntax: regexp # defaults following lines to non-rooted regexps
syntax: glob # defaults following lines to non-rooted globs
re:pattern # non-rooted regular expression
glob:pattern # non-rooted glob
pattern # pattern of the current default type
if sourceinfo is set, returns a list of tuples:
(pattern, lineno, originalline). This is useful to debug ignore patterns.
"""
syntaxes = {
"re": "relre:",
"regexp": "relre:",
"glob": "relglob:",
"include": "include",
"subinclude": "subinclude",
}
syntax = "relre:"
patterns = []
fp = open(filepath, "rb")
for lineno, line in enumerate(util.iterfile(fp), start=1):
if "#" in line:
global _commentre
if not _commentre:
_commentre = util.re.compile(br"((?:^|[^\\])(?:\\\\)*)#.*")
# remove comments prefixed by an even number of escapes
m = _commentre.search(line)
if m:
line = line[: m.end(1)]
# fixup properly escaped comments that survived the above
line = line.replace("\\#", "#")
line = line.rstrip()
if not line:
continue
if line.startswith("syntax:"):
s = line[7:].strip()
try:
syntax = syntaxes[s]
except KeyError:
if warn:
warn(_("%s: ignoring invalid syntax '%s'\n") % (filepath, s))
continue
linesyntax = syntax
for s, rels in pycompat.iteritems(syntaxes):
if line.startswith(rels):
linesyntax = rels
line = line[len(rels) :]
break
elif line.startswith(s + ":"):
linesyntax = rels
line = line[len(s) + 1 :]
break
if sourceinfo:
patterns.append((linesyntax + line, lineno, line))
else:
patterns.append(linesyntax + line)
fp.close()
return patterns |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def insert_accented(self, c, accent):
if c.isalpha():
if c.isupper():
cap = 'capital'
else:
cap = 'small'
try:
c = lookup("latin %s letter %c with %s" % (cap, c, accent))
self.insert(INSERT, c)
# Prevent plain letter from being inserted too, tell Tk to
# stop handling this event
return "break"
except KeyError, e:
pass |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def GetCompletions_UnicodeDescription_test( app ):
filepath = PathToTestFile( 'unicode.py' )
completion_data = BuildRequest( filepath = filepath,
filetype = 'python',
contents = ReadFile( filepath ),
force_semantic = True,
line_num = 5,
column_num = 3)
results = app.post_json( '/completions',
completion_data ).json[ 'completions' ]
assert_that( results, has_item(
has_entry( 'detailed_info', contains_string( u'aafäö' ) ) ) ) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _parse_filter():
op = pyparsing.oneOf('! & |')
lpar = pyparsing.Literal('(').suppress()
rpar = pyparsing.Literal(')').suppress()
k = pyparsing.Word(pyparsing.alphanums)
# NOTE: We may need to expand on this list, but as this is not a real
# LDAP server we should be OK.
# Value to contain:
# numbers, upper/lower case letters, astrisk, at symbol, minus, full
# stop, backslash or a space
v = pyparsing.Word(pyparsing.alphanums + "-*@.\\ äöü")
rel = pyparsing.oneOf("= ~= >= <=")
expr = pyparsing.Forward()
atom = pyparsing.Group(lpar + op + expr + rpar) \
| pyparsing.Combine(lpar + k + rel + v + rpar)
expr << atom + pyparsing.ZeroOrMore( expr )
return expr |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def decode(value):
if isinstance(value, bytes):
value = value.decode(errors="surrogateescape")
for char in ("\\", "\n", "\t"):
value = value.replace(
char.encode(encoding="unicode-escape").decode(), char
)
return value |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def encode(value):
if isinstance(value, bytes):
value = value.decode(errors="surrogateescape")
for char in ("\\", "\n", "\t"):
value = value.replace(
char, char.encode(encoding="unicode-escape").decode()
)
return value |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def deserialize(self, value):
"""Cast raw string to appropriate type."""
return decode(value) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def serialize(self, value, display=False):
if value is None:
return ""
return encode(value) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def deserialize(self, value):
value = decode(value)
validators.validate_required(value, self._required)
if not value:
return None
value = int(value)
validators.validate_choice(value, self._choices)
validators.validate_minimum(value, self._minimum)
validators.validate_maximum(value, self._maximum)
return value |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def deserialize(self, value):
value = decode(value)
if "\n" in value:
values = re.split(r"\s*\n\s*", value)
else:
values = re.split(r"\s*,\s*", value)
values = tuple(v.strip() for v in values if v.strip())
validators.validate_required(values, self._required)
return tuple(values) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def serialize(self, value, display=False):
if not value:
return ""
return "\n " + "\n ".join(encode(v) for v in value if v) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def write(self, s):
sys.stdout.buffer.write(s) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def __str__(self):
return "(%s,%s)/%d" % (self.saddr, self.gaddr, self.glen) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def limitStrLessThen128Char(self, strStr=None):
if len(strStr) > 128:
logging.info("limit str less then 128 char")
return strStr[:127] + u"_"
else:
return strStr |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def chunkstring(s, n):
return [ s[i:i+n] for i in xrange(0, len(s), n) ] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _pad(self, s):
return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _unpad(s):
return s[:-ord(s[len(s)-1:])] |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _get_drag_data(self, dragged_item):
return str(self._items.index(dragged_item)) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def _get_item_name(index):
return _("Element") + " " + str(index) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def device_is_id(self):
pattern = r'[A-Za-z0-9]{8}-[A-Za-z0-9]{4}-[A-Za-z0-9]{4}-[A-Za-z0-9]{4}-[A-Za-z0-9]{12}'
if re.match(pattern, self.device):
return True
return False |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def columnize(self, list, displaywidth=80):
"""Display a list of strings as a compact set of columns.
Each column is only as wide as necessary.
Columns are separated by two spaces (one was not legible enough).
"""
if not list:
self.stdout.write("<empty>\n")
return
nonstrings = [i for i in range(len(list))
if not isinstance(list[i], str)]
if nonstrings:
raise TypeError("list[i] not a string for i in %s"
% ", ".join(map(str, nonstrings)))
size = len(list)
if size == 1:
self.stdout.write('%s\n'%str(list[0]))
return
# Try every row count from 1 upwards
for nrows in range(1, len(list)):
ncols = (size+nrows-1) // nrows
colwidths = []
totwidth = -2
for col in range(ncols):
colwidth = 0
for row in range(nrows):
i = row + nrows*col
if i >= size:
break
x = list[i]
colwidth = max(colwidth, len(x))
colwidths.append(colwidth)
totwidth += colwidth + 2
if totwidth > displaywidth:
break
if totwidth <= displaywidth:
break
else:
nrows = len(list)
ncols = 1
colwidths = [0]
for row in range(nrows):
texts = []
for col in range(ncols):
i = row + nrows*col
if i >= size:
x = ""
else:
x = list[i]
texts.append(x)
while texts and not texts[-1]:
del texts[-1]
for col in range(len(texts)):
texts[col] = texts[col].ljust(colwidths[col])
self.stdout.write("%s\n"%str(" ".join(texts))) |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def do_blob(self, s):
print("blob!") |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def do_bob(self, s):
print("bob!") |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def hex_encoder(*args, **kwargs): # real signature unknown
pass |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def get_split_names( name ):
split_name_list = name.split("/")
for i in range(0, len(split_name_list)):
split_name_list[i] = split_name_list[i].strip()
return split_name_list |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def esc_char(name):
if "'" in name:
return "$$" + name + "$$"
else:
return "'" + name + "'" |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def validate_description(cls, desc):
desc = str(desc)
# We cannot fail when the description is too long, since we must
# support older engine that may send such values, or old disks
# with long description.
if len(desc) > sc.DESCRIPTION_SIZE:
cls.log.warning("Description is too long, truncating to %d bytes",
sc.DESCRIPTION_SIZE)
desc = desc[:sc.DESCRIPTION_SIZE]
return desc |
def __init__(self):
self.filediff = None
meldsettings.connect('changed', self.on_setting_changed) | def FSPairs (self, FS) :
feats = dict()
for feat in FS.split():
if "=" not in feat:continue
feat = re.sub("af='+","af='",feat.replace("dmrel=",'drel='))
assert len(feat.split("=")) == 2
attribute,value = feat.split("=")
feats[attribute] = value
return feats |