Comparison methods for sppasTag.
Label'tags can be of 3 types in anndata (str, num, bool) so
that this class allows to create different comparison methods
depending on the type of the tags.
Three different ways to compare a tag content to a given string
>>> tc = sppasTagCompare()
>>> tc.exact(sppasTag("abc"), u("abc"))
>>> tc.methods['exact'](sppasTag("abc"), u("abc"))
>>> tc.get('exact')(sppasTag("abc"), u("abc"))
Create a sppasTagCompare instance.
def __init__(self):
"""Create a sppasTagCompare instance."""
super(sppasTagCompare, self).__init__()
self.methods['exact'] = sppasTagCompare.exact
self.methods['iexact'] = sppasTagCompare.iexact
self.methods['startswith'] = sppasTagCompare.startswith
self.methods['istartswith'] = sppasTagCompare.istartswith
self.methods['endswith'] = sppasTagCompare.endswith
self.methods['iendswith'] = sppasTagCompare.iendswith
self.methods['contains'] = sppasTagCompare.contains
self.methods['icontains'] = sppasTagCompare.icontains
self.methods['regexp'] = sppasTagCompare.regexp
self.methods['greater'] = sppasTagCompare.greater
self.methods['lower'] = sppasTagCompare.lower
self.methods['equal'] = sppasTagCompare.equal
self.methods['bool'] = sppasTagCompare.bool
Test if two texts strictly contain the same characters.
AnnDataTypeError
@staticmethod
def exact(tag, text):
"""Test if two texts strictly contain the same characters.
:param tag: (sppasTag) Tag to compare.
:param text: (unicode) Unicode string to be compared with.
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
if not isinstance(text, text_type):
raise AnnDataTypeError(text, text_type)
return tag.get_content() == text
Case-insensitive exact.
AnnDataTypeError
@staticmethod
def iexact(tag, text):
"""Case-insensitive exact.
:param tag: (sppasTag) Tag to compare.
:param text: (unicode) Unicode string to be compared with.
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
if not isinstance(text, text_type):
raise AnnDataTypeError(text, text_type)
return tag.get_content().lower() == text.lower()
Test if first text starts with the characters of the second text.
AnnDataTypeError
@staticmethod
def startswith(tag, text):
"""Test if first text starts with the characters of the second text.
:param tag: (sppasTag) Tag to compare.
:param text: (unicode) Unicode string to be compared with.
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
if not isinstance(text, text_type):
raise AnnDataTypeError(text, text_type)
return tag.get_content().startswith(text)
Case-insensitive startswith.
AnnDataTypeError
@staticmethod
def istartswith(tag, text):
"""Case-insensitive startswith.
:param tag: (sppasTag) Tag to compare.
:param text: (unicode) Unicode string to be compared with.
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
if not isinstance(text, text_type):
raise AnnDataTypeError(text, text_type)
return tag.get_content().lower().startswith(text.lower())
Test if first text ends with the characters of the second text.
AnnDataTypeError
@staticmethod
def endswith(tag, text):
"""Test if first text ends with the characters of the second text.
:param tag: (sppasTag) Tag to compare.
:param text: (unicode) Unicode string to be compared with.
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
if not isinstance(text, text_type):
raise AnnDataTypeError(text, text_type)
return tag.get_content().endswith(text)
Case-insensitive endswith.
AnnDataTypeError
@staticmethod
def iendswith(tag, text):
"""Case-insensitive endswith.
:param tag: (sppasTag) Tag to compare.
:param text: (unicode) Unicode string to be compared with.
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
if not isinstance(text, text_type):
raise AnnDataTypeError(text, text_type)
return tag.get_content().lower().endswith(text.lower())
Test if the first text contains the second text.
AnnDataTypeError
@staticmethod
def contains(tag, text):
"""Test if the first text contains the second text.
:param tag: (sppasTag) Tag to compare.
:param text: (unicode) Unicode string to be compared with.
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
if not isinstance(text, text_type):
raise AnnDataTypeError(text, text_type)
return text in tag.get_content()
Case-insensitive contains.
AnnDataTypeError
@staticmethod
def icontains(tag, text):
"""Case-insensitive contains.
:param tag: (sppasTag) Tag to compare.
:param text: (unicode) Unicode string to be compared with.
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
if not isinstance(text, text_type):
raise AnnDataTypeError(text, text_type)
return text.lower() in tag.get_content().lower()
test if text matches pattern.
AnnDataTypeError
@staticmethod
def regexp(tag, pattern):
"""test if text matches pattern.
:param tag: (sppasTag) Tag to compare.
:param pattern: (unicode) Pattern to search.
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
text = tag.get_content()
return True if re.match(pattern, text) else False
Return True if numerical value of the tag is equal to x.
AnnDataTypeError
@staticmethod
def equal(tag, x):
"""Return True if numerical value of the tag is equal to x.
:param tag: (sppasTag) Tag to compare.
:param x: (int, float)
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
if tag.get_type() not in ['int', 'float']:
raise AnnDataTypeError(tag, 'int/float')
if sppasType().is_number(x) is False:
raise AnnDataTypeError(x, 'int/float')
return tag.get_typed_content() == x
Return True if numerical value of the tag is greater than x.
AnnDataTypeError
@staticmethod
def greater(tag, x):
"""Return True if numerical value of the tag is greater than x.
:param tag: (sppasTag) Tag to compare.
:param x: (int, float)
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
if tag.get_type() not in ['int', 'float']:
raise AnnDataTypeError(tag, 'int/float')
if sppasType().is_number(x) is False:
raise AnnDataTypeError(x, 'int/float')
return tag.get_typed_content() > x
Return True if numerical value of the tag is lower than x.
AnnDataTypeError
@staticmethod
def lower(tag, x):
"""Return True if numerical value of the tag is lower than x.
:param tag: (sppasTag) Tag to compare.
:param x: (int, float)
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
if tag.get_type() not in ['int', 'float']:
raise AnnDataTypeError(tag, 'int/float')
if sppasType().is_number(x) is False:
raise AnnDataTypeError(x, 'int/float')
return tag.get_typed_content() < x
Return True if boolean value of the tag is equal to boolean x.
AnnDataTypeError
@staticmethod
def bool(tag, x):
"""Return True if boolean value of the tag is equal to boolean x.
:param tag: (sppasTag) Tag to compare.
:param x: (bool)
:returns: (bool)
:raises: AnnDataTypeError
"""
if isinstance(tag, sppasTag) is False:
raise AnnDataTypeError(tag, 'sppasTag')
if tag.get_type() != 'bool':
raise AnnDataTypeError(tag, 'bool')
if sppasType().is_bool(x) is False:
raise AnnDataTypeError(x, 'bool')
return tag.get_typed_content() == x