"""A collection of data structures for values of attributes on nodes/edges of graphs.
Implements the following data structures:
* `AttributeSet` -- a base class for attribute sets in `ReGraph`,
provides an interface, implements some common behaviour;
* `FiniteSet` -- wrapper for Python finite sets, inherits `AttributeSet`;
* `RegexSet` -- a class for possibly infinite sets of strings given by
regular expressions. It uses the `greenery <https://github.com/qntm/greenery>`_
library for finding inclusion and intersection of regular expressions,
its method `match` can be used to test if a given string is in
a set of strings defined by regular expressions;
* `IntegerSet` -- a class for possibly infinite sets of integers
defined by a set of disjoint intervals, inherits `AttributeSet`,
provides the method `contains` for testing if a given integer is in
the set of integers.
TODO:
* `RealSet` -- a class for possibly infinite sets of reals
defined by a set of open/closed intervals, inherits `AttributeSet`,
provides the method `contains` for testing if a given real is in
the set of reals.
"""
import copy
import re
import numpy as np
import math
import sys
from greenery.lego import parse
from regraph.exceptions import AttributeSetError
try:
re._pattern_type = re.Pattern
except:
pass
def _hashify(d):
"""Hashify a dictionary to a list of tuples."""
result = []
for key, value in d.items():
if type(value) is dict:
result.append((key, _hashify(value)))
else:
result.append((key, value))
return tuple(result)
def _regex_to_string(a):
if isinstance(a, str):
return a
elif isinstance(a, re._pattern_type):
return a.pattern
elif isinstance(a, RegexSet):
if a.pattern is not None:
return a.pattern
else:
return None
else:
raise AttributeSetError("Cannot convert regex to string!")
class AttributeSet(object):
"""Base class for ReGraph attribute sets."""
def __bool__(self):
"""Bool representation of attribute set."""
return not self.is_empty()
def __len__(self):
"""Length of attribute set."""
return len(self)
def __eq__(self, other):
"""Test equality with another set."""
return self.issubset(other) and other.issubset(self)
def __ge__(self, other):
"""Test if greater or equal than another set."""
return other.issubset(self)
def __gt__(self, other):
"""Test if strictly greater than another set."""
return other.issubset(self) and not self.issubset(other)
def __lt__(self, other):
"""Test if strictly less than another set."""
return self.issubset(other) and not other.issubset(self)
def __le__(self, other):
"""Test if less or equal than another set."""
return self.issubset(other)
def union(self, other):
"""Find union attribute set."""
pass
def intersect(self, other):
"""Find intersection attribute set."""
pass
def difference(self, other):
"""Find difference attribute set."""
pass
def issubset(self, other):
"""Test if subset of another set."""
pass
@classmethod
def from_json(cls, json_data):
"""Create attribute set object from json-like dictionary."""
if "type" in json_data.keys():
init_args = None
if "data" in json_data.keys():
if not (len(json_data["data"]) == 1 and
json_data["data"][0] is None):
init_args = json_data["data"]
# JSON cannot dump tuples, so finite set of tuples is usually
# represented as a list of lists, if we read from json list of
# lists, we interpret them as a set of tuples
if json_data["type"] == "FiniteSet" and init_args is not None:
for i, element in enumerate(init_args):
if type(element) == list:
init_args[i] = tuple(element)
if json_data["type"] == "IntegerSet" and init_args is not None:
for i, element in enumerate(init_args):
if element[0] == "-inf":
init_args[i][0] = -math.inf
if element[1] == "inf":
init_args[i][1] = math.inf
return getattr(sys.modules[__name__], json_data["type"])(init_args)
def toset(self):
if isinstance(self, FiniteSet):
return self.fset
else:
raise ValueError(
"Cannot convert AttributeSet of type "
"'{}' to a Python set".format(type(self)))
class FiniteSet(AttributeSet):
"""Wrapper for finite sets as attribute sets.
Attributes
----------
fset : set
Python finite set that is being wrapped by the object
"""
def __init__(self, fset=None):
"""Initialize finite set object."""
if fset is None or fset == {None}:
self.fset = set()
else:
if type(fset) == set:
self.fset = copy.deepcopy(fset)
elif type(fset) == list:
self.fset = set(fset)
elif type(fset) == dict:
self.fset = set(_hashify(fset))
else:
self.fset = {fset}
def __str__(self):
"""String represenation of FiniteSet."""
return str(self.fset)
def __repr__(self):
"""Repr represenation of FiniteSet."""
return str(self.fset)
def __iter__(self):
"""Iterator over FiniteSet."""
for element in self.fset:
yield element
def __len__(self):
"""Length of finite set."""
return len(self.fset)
def issubset(self, other):
"""Test if subset of another set.
Parameters
----------
other : set, FiniteSet, RegexSet, IntegerSet, EmptySet or UniversalSet
Returns
-------
`True` is `self` defines a subset of `other`, `False` otherwise
"""
if type(other) == set:
return self.fset.issubset(other)
elif isinstance(other, FiniteSet):
return self.fset.issubset(other.fset)
elif isinstance(other, RegexSet):
for element in self.fset:
if element is not None:
if not other.match(str(element)):
return False
elif isinstance(other, IntegerSet):
for element in self.fset:
if element is not None:
if type(element) != int:
try:
element = int(element)
except:
raise AttributeSetError(
"Element '%s' of a finite set is not an "
"integer (%s)" %
(str(element), str(type(element)))
)
if not other.contains(element):
return False
elif isinstance(other, EmptySet):
return False
elif isinstance(other, UniversalSet):
return True
else:
return False
return True
def union(self, other):
"""Find the union with another set.
Parameters
----------
other : set, FiniteSet, RegexSet, IntegerSet, EmptySet or UniversalSet
Returns
-------
The union set
"""
if type(other) == set:
return FiniteSet(self.fset.union(other))
elif isinstance(other, FiniteSet):
return FiniteSet(self.fset.union(other.fset))
elif isinstance(other, RegexSet):
return RegexSet(self.fset).union(other)
elif isinstance(other, IntegerSet):
int_elements = set()
for element in self.fset:
if type(element) != int:
try:
int_elements.add(int(element))
except:
raise AttributeSetError(
"Element '%s' of a finite set is not an "
"integer (%s)" %
(str(element), str(type(element)))
)
else:
int_elements.add(element)
return IntegerSet(self.fset).union(other)
elif isinstance(other, EmptySet):
return copy.deepcopy(self)
elif isinstance(other, UniversalSet):
return UniversalSet()
else:
raise AttributeSetError("Invalid type of attribute set!")
def intersection(self, other):
"""Find the intersection set with another set.
Parameters
----------
other : set, FiniteSet, RegexSet, IntegerSet, EmptySet or UniversalSet
Returns
-------
The intersection set
"""
if type(other) == set:
return FiniteSet(self.fset.intersection(other))
elif isinstance(other, FiniteSet):
# print("here")
# print(other.fset, self.fset)
return FiniteSet(self.fset.intersection(other.fset))
elif isinstance(other, RegexSet):
intersection = []
for element in self.fset:
if other.match(str(element)):
intersection.append(element)
return FiniteSet(intersection)
elif isinstance(other, IntegerSet):
for element in self.fset:
if type(element) != int:
try:
element = int(element)
except:
raise AttributeSetError(
"Element '%s' of a finite set is not an "
"integer (%s)" %
(str(element), str(type(element)))
)
return IntegerSet(self.fset).intersection(other)
elif isinstance(other, EmptySet):
return EmptySet()
elif isinstance(other, UniversalSet):
return copy.deepcopy(self)
else:
raise AttributeSetError("Invalid type of attribute set!")
def difference(self, other):
"""Find the difference set with another set.
Finds a `self` - `other` set.
Parameters
----------
other : set, FiniteSet, RegexSet, IntegerSet, EmptySet or UniversalSet
Returns
-------
The difference set
"""
if type(other) == set:
return FiniteSet(self.fset.difference(other))
elif isinstance(other, FiniteSet):
return FiniteSet(self.fset.difference(other.fset))
elif isinstance(other, RegexSet):
elements_to_keep = []
for element in self.fset:
if not other.match(str(element)):
elements_to_keep.append(element)
return FiniteSet(elements_to_keep)
elif isinstance(other, IntegerSet):
for element in self.fset:
if type(element) != int:
try:
element = int(element)
except:
raise AttributeSetError(
"Element '%s' of a finite set is not an "
"integer (%s)" %
(str(element), str(type(element)))
)
return IntegerSet(self.fset).difference(other)
elif isinstance(other, EmptySet):
return copy.deepcopy(self)
elif isinstance(other, UniversalSet):
return FiniteSet()
else:
raise AttributeSetError("Invalid type of attribute set!")
def is_empty(self):
"""Test if finite set is empty."""
return self.fset is None or len(self.fset) == 0
def is_universal(self):
"""Test if finite set is universal.
Returns
-------
False, as finite set is never a universal set
"""
return False
def to_json(self):
"""JSON represenation."""
json_data = {}
json_data["type"] = "FiniteSet"
json_data["data"] = list(self.fset)
return json_data
def update(self, element):
"""Update finite set."""
self.fset.update(element)
def add(self, element):
"""Add an element."""
self.fset.add(element)
class RegexSet(AttributeSet):
"""Class defining a set of strings recognized by a regular expression.
RegexSet is defined by a regular expression, and
is morally associated to a set of strings that
the regular expression recognizes.
Attributes
----------
pattern : str
Regular expression pattern
"""
def __init__(self, regexp):
"""Initialize a set of strings defined by a regexp pattern.
Parameters
----------
regexp : str
Regular expression pattern
"""
if regexp is not None:
if type(regexp) != str:
strings = []
for element in regexp:
strings.append(str(element))
concat = "|".join(strings)
self.pattern = concat
else:
self.pattern = regexp
else:
self.pattern = None
def __str__(self):
"""String representation of RegexSet obj."""
if self.pattern:
if self.is_universal():
return "<UniversalRegexSet>"
return self.pattern
else:
return "<EmptyRegexSet>"
def issubset(self, other):
"""Test regexp inclusion relation.
Tests if a set defined by `self` is a included
in a set defined by `other`.
Parameters
----------
other : set, str, re._pattern_type, RegexSet
Another regex to test inclusion.
Returns
-------
`True` is `self` defines a subset of `other`, `False` otherwise
Raises
------
AttributeSetError
If the type `other` is not recognized.
"""
if self.pattern is None:
return True
else:
self_exp = parse(self.pattern)
def included(a):
if isinstance(a, str):
other_exp = parse(a)
elif isinstance(a, re._pattern_type):
other_exp = parse(a.pattern)
elif isinstance(a, RegexSet):
if a.pattern:
other_exp = parse(a.pattern)
else:
return False
else:
raise AttributeSetError(
"Regexp object should be of type `str` or `re._pattern_type`!"
)
return (self_exp & other_exp.everythingbut()).empty()
if isinstance(other, set):
res = True
for element in other:
if element is not None and not included(element):
res = False
break
else:
res = included(other)
return res
def union(self, other):
"""Find the union with another set.
The union is found in the following ways:
* If `other` is a string, a Python dict or a FiniteSet
the result of the union is a simple concatenation of the
string representations of the elements of `other`
with the pattern of `self`.
* If `other` is an instance of `UniversalSet`, the union
is a `UniversalSet` object.
* If `other` is an instance of `EmptySet`, the union is
a copy of `self`.
Parameters
----------
other : set, str, re._pattern_type, RegexSet
Returns
-------
result : RegexSet
The union set
"""
if self.pattern is None:
other_str = _regex_to_string(other)
if other_str is None:
return RegexSet.empty()
else:
return RegexSet(other_str)
if self.is_universal():
return RegexSet.universal()
patterns = []
if isinstance(other, set) or isinstance(other, FiniteSet):
for element in other:
element_str = _regex_to_string(element)
if element_str is not None:
patterns.append(element_str)
elif isinstance(other, UniversalSet):
return UniversalSet()
elif isinstance(other, EmptySet):
return copy.deepcopy(self)
else:
other_str = _regex_to_string(other)
if other_str is None:
return self.copy()
else:
patterns.append(other_str)
new_pattern = self.pattern + "|" + "|".join(patterns)
result = RegexSet(new_pattern)
return result
def intersection(self, other):
"""Find the intersection of two regexps.
This method uses greenery library to find and
reduce the intersection pattern.
* If `other` is a string, a Python dict or a FiniteSet,
it is converted to a regex pattern, after which it
is parsed by `greenery.lego.parse` method and its
intersection with the pattern of the `self` is found.
The library `greenery` finds the intersection between two
regex's by constructing corresponding FSM's (finite state
machines) and finding their intersection, after which it
is converted back to a regex. See more details here:
https://github.com/qntm/greenery
* If `other` is an instance of `EmpySet`, the intersection
is a `EmpySet` object.
* If `other` is an instance of `UniversalSet`, the intersection
is a copy of `self`.
Parameters
----------
other : set, str, re._pattern_type, RegexSet
Returns
-------
result : RegexSet
The union set
"""
if self.pattern is None:
return RegexSet.empty()
if self.is_universal():
if isinstance(other, set):
universal_flag = True
other_exp = []
for el in other:
exp = RegexSet(_regex_to_string(el))
other_exp.append(exp)
if not exp.is_universal():
universal_flag = False
if universal_flag:
return RegexSet.universal()
else:
result_obj = RegexSet.empty()
for exp in other_exp:
result_obj.union(exp)
return result_obj
else:
other_obj = RegexSet(_regex_to_string(other))
if other_obj.is_universal():
return RegexSet.universal()
else:
return other_obj
self_exp = parse(self.pattern)
other_exp = []
if isinstance(other, set):
for exp in other:
exp_str = _regex_to_string(exp)
if exp_str is None:
return RegexSet.empty()
other_exp.append(parse(exp_str))
elif isinstance(other, UniversalSet):
return copy.deepcopy(self)
elif isinstance(other, EmptySet):
return EmptySet()
else:
other_str = _regex_to_string(other)
if other_str is None:
return RegexSet.empty()
other_exp.append(parse(other_str))
intersect_exp = self_exp
for exp in other_exp:
intersect_exp = intersect_exp.intersection(exp)
return RegexSet(str(intersect_exp))
def difference(self, other):
"""Find the difference of two regexps.
This method uses greenery library to find and
reduce the difference pattern between two regex's.
* If `other` is a string, a Python dict or a FiniteSet,
it is converted to a regex pattern, after which it
is parsed by `greenery.lego.parse` method and its
difference with the pattern of the `self` is found.
See more details here:
https://github.com/qntm/greenery
* If `other` is an instance of `EmpySet`, the difference
is a copy of `self`.
* If `other` is an instance of `UniversalSet`, the difference
is an instance of `EmptySet`.
Parameters
----------
other : set, str, re._pattern_type, RegexSet
Returns
-------
result : RegexSet
The union set
"""
if self.pattern is None:
return RegexSet.empty()
other_exp = []
if isinstance(other, set):
for exp in other:
exp_str = _regex_to_string(exp)
if exp_str is not None:
other_exp.append(parse(exp_str))
else:
other_str = _regex_to_string(other)
if other_str is not None:
other_exp.append(parse(other_str))
else:
return self.copy()
complement_exp = parse(self.pattern)
for exp in other_exp:
complement_exp = complement_exp.difference(exp)
return RegexSet(str(complement_exp.reduce()))
@classmethod
def from_finite_set(cls, fset):
"""Create a regexp from ordinary finite set.
All the elements of the set will be cast to str.
"""
return cls("|".join([str(el) for el in fset]))
@classmethod
def universal(cls):
"""Create a RegexSet object matching any string."""
return cls("(.|\n)*")
@classmethod
def empty(cls):
"""Create a RegexSet object not matching any string."""
return cls(None)
def is_universal(self):
"""Test if an object is a universal RegexSet."""
if self.pattern and self.pattern == "(.|\n)*":
return True
return False
def is_empty(self):
"""Test if an object is an empty RegexSet."""
return self.pattern is None
def match(self, string):
"""Check if a string is in RegexSet."""
if self.pattern is not None:
return re.compile(self.pattern).fullmatch(string) is not None
else:
return False
def to_json(self):
"""JSON represenation of RegexSet."""
json_data = {}
json_data["type"] = "RegexSet"
json_data["data"] = self.pattern
return json_data
class IntegerSet(AttributeSet):
"""Set of integers defined by a list of disjoint intervals.
Attributes
----------
intervals : list
List of sorted intervals defining an integer set.
"""
def __init__(self, interval_list):
"""Initialize IntegerSet object.
Takes a collection of tuples or ints
normalizes the intervals and singletons
and creates a set of intervals and singletons.
"""
starts = list()
ends = list()
for interval in interval_list:
try:
start, end = interval
if start > end:
raise AttributeSetError(
"Invalid integer interval: [%s, %s]" %
(str(start), str(end))
)
else:
try:
start = int(start)
except OverflowError:
pass
starts.append(start)
try:
end = int(end)
except OverflowError:
pass
ends.append(end)
except (TypeError, ValueError):
try:
interval = int(interval)
except OverflowError:
pass
starts.append(interval)
ends.append(interval)
new_intervals = list()
sorted_starts_ind = np.argsort(starts)
visited = set()
for i, index in enumerate(sorted_starts_ind):
if index not in visited:
visited.add(index)
current_end = ends[index]
for j in range(i + 1, len(sorted_starts_ind)):
if starts[sorted_starts_ind[j]] - 1 > ends[index]:
break
else:
visited.add(sorted_starts_ind[j])
current_end = max(
current_end, ends[sorted_starts_ind[j]]
)
# in case new interval overlaps
# with newly constructed interval
if len(new_intervals) > 0 and\
starts[index] <= new_intervals[-1][1] + 1:
new_intervals[-1] = (
new_intervals[-1][0],
max(current_end, new_intervals[-1][1])
)
else:
new_intervals.append((starts[index], current_end))
self.intervals = new_intervals
return
def __str__(self):
"""String representation of IntegerSet obj."""
interval_strs = []
for start, end in self.intervals:
if start > -math.inf:
start_str = "%d" % start
else:
start_str = "-inf"
if end < math.inf:
end_str = "%d" % end
else:
end_str = "inf"
if start_str != end_str:
interval_strs.append("[" + start_str + ", " + end_str + "]")
else:
interval_strs.append("{" + start_str + "}")
return ", ".join(interval_strs)
def issubset(self, other):
"""Test set inclusion for intervals of ints."""
for start, end in self.intervals:
found = False
for other_start, other_end in other.intervals:
if start >= other_start and end <= other_end:
found = True
break
if not found:
return False
return True
def union(self, other):
"""Union of two integer sets."""
if isinstance(other, IntegerSet):
return IntegerSet(self.intervals + other.intervals)
elif isinstance(other, set):
other_intervals = []
for element in other:
try:
int_element = int(element)
except:
raise AttributeSetError(
"Set '{}' contains non-integer element '{}'".format(
str(other), element))
if not self.contains(int_element):
other_intervals.append((int_element, int_element))
return IntegerSet(self.intervals + other_intervals)
elif isinstance(other, FiniteSet):
other_intervals = []
for element in other.fset:
try:
int_element = int(element)
except:
raise AttributeSetError(
"Set '{}' contains non-integer element '{}'".format(
str(other), element))
if not self.contains(int_element):
other_intervals.append((int_element, int_element))
return IntegerSet(self.intervals + other_intervals)
elif isinstance(other, UniversalSet):
return UniversalSet()
elif isinstance(other, EmptySet):
return copy.deepcopy(self)
else:
raise AttributeSetError(
"Cannot intersect '%s' with an integer set!" % str(other)
)
def intersection(self, other):
"""Intersection of two integer sets."""
def interval_intersect(interval1, interval2):
start1, end1 = interval1
start2, end2 = interval2
common_start = max(start1, start2)
common_end = min(end1, end2)
if common_start <= common_end:
return (common_start, common_end)
return None
new_intervals = []
if isinstance(other, IntegerSet):
for interval1 in self.intervals:
for interval2 in other.intervals:
common = interval_intersect(interval1, interval2)
if common:
new_intervals.append(common)
return IntegerSet(new_intervals)
elif isinstance(other, set):
try:
for element in other:
int_element = int(element)
if self.contains(int_element):
new_intervals.append((int_element, int_element))
return IntegerSet(new_intervals)
except:
raise AttributeSetError(
"Set '%s' contains non-integer elements!" % str(other)
)
elif isinstance(other, FiniteSet):
try:
for element in other.fset:
int_element = int(element)
if self.contains(int_element):
new_intervals.append((int_element, int_element))
return IntegerSet(new_intervals)
except:
raise AttributeSetError(
"Set '%s' contains non-integer elements!" % str(other)
)
elif isinstance(other, UniversalSet):
return copy.deepcopy(self)
elif isinstance(other, EmptySet):
return EmptySet()
else:
raise AttributeSetError(
"Cannot intersect '%s' with an integer set!" % str(other)
)
def difference(self, other):
"""Difference of self with the other."""
def is_subinterval(a, b):
start_a, end_a = a
start_b, end_b = b
if start_a >= start_b and end_a <= end_b:
return True
return False
def create_cuts(small, large):
small_start, small_end = small
large_start, large_end = large
cuts = []
if small_start > large_start:
cuts.append((large_start, small_start - 1))
if small_end < large_end:
cuts.append((small_end + 1, large_end))
return cuts
new_intervals = []
intersect = self.intersection(other)
for interval1 in self.intervals:
cuts = [interval1]
for interval2 in intersect.intervals:
for i, cut in enumerate(cuts):
if is_subinterval(interval2, cut):
new_cuts = create_cuts(interval2, cut)
cuts[i] = new_cuts
new_cuts = []
for subcuts in cuts:
if isinstance(subcuts, list):
for cut in subcuts:
new_cuts.append(cut)
else:
new_cuts.append(subcuts)
cuts = new_cuts
if len(cuts) == 0:
new_intervals.append(interval1)
else:
new_intervals += cuts
return IntegerSet(new_intervals)
@classmethod
def universal(cls):
"""Universal integer set."""
return cls([(-math.inf, math.inf)])
@classmethod
def empty(cls):
"""Empty integer set."""
return cls([])
def is_universal(self):
"""Test universality."""
return self == IntegerSet.universal()
def is_empty(self):
"""Test if empty."""
return self == IntegerSet.empty()
@classmethod
def from_finite_set(cls, s):
"""Create Integer set object from a finite set."""
intervals = []
for el in s:
if type(el) != int:
val = int(el)
else:
val = el
intervals.append(val)
return cls(intervals)
def contains(self, num):
"""Test if provided integer is in integer set."""
found = False
for start, end in self.intervals:
if num >= start and num <= end:
found = True
break
return found
def to_json(self):
"""JSON represenation of IntegerSet."""
json_data = {}
json_data["type"] = "IntegerSet"
json_data["data"] = []
for start, end in self.intervals:
if math.isinf(-start):
new_start = "-inf"
else:
new_start = start
if math.isinf(end):
new_end = "inf"
else:
new_end = end
json_data["data"].append([new_start, new_end])
return json_data
class EmptySet(AttributeSet):
"""Empty attribute set."""
def __len__(self):
"""Return length."""
return 0
def __str__(self):
"""String representation of an empty set."""
return "EmptySet"
def __repr__(self):
"""Representation of an empty set."""
return "regraph.attribute_set.EmptySet"
def issubset(self, other):
"""Test if subset of another set."""
return True
def intersect(self, other):
"""Intersect with another set."""
return EmptySet()
def union(self, other):
"""Find union with another set."""
return copy.deepcopy(other)
def difference(self, other):
"""Find difference with another."""
return EmptySet()
def is_universal(self):
"""Test if universal."""
return False
def is_empty(self):
"""Test if empty."""
return True
def to_json(self):
"""JSON represenation of EmptySet."""
json_data = {}
json_data["type"] = "EmptySet"
return json_data
class UniversalSet(AttributeSet):
"""Universal attribute set."""
def __init__(self, *arg):
super().__init__()
return
def __len__(self):
"""Return length."""
return math.inf
def __str__(self):
"""."""
return "UniversalSet"
def issubset(self, other):
"""Test if subset of other set."""
if isinstance(other, AttributeSet):
return other.is_universal()
else:
return False
def is_universal(self):
"""Test if universal."""
return True
def is_empty(self):
"""Test if empty."""
return False
def intersection(self, other):
"""Intersect with another set."""
return copy.deepcopy(other)
def union(self, other):
"""Find union with another set."""
return UniversalSet()
def difference(self, other):
"""Difference with another set."""
return other.__class__.universal().difference(other)
def to_json(self):
"""JSON represenation of UniversalSet."""
json_data = {}
json_data["type"] = "UniversalSet"
return json_data
