def save(self, data):
diagram = None
# try to retrieve an existing diagram
if data['id'] != None and data['id'] != "":
diagram = Diagram.get_by_key_name(data['id'])
# if we don't have on, create a new one
if diagram == None:
diagram = Diagram.create( id = data['id'],
name = data['name'],
source = data['source'],
width = data['width'],
height = data['height'],
description = data['description'],
notes = data['notes'],
owner = data['author'] )
else:
# update the relevant data
diagram.name = data['name'];
diagram.source = data['source'];
diagram.width = data['width'];
diagram.height = data['height'];
diagram.descripton = data['description'];
diagram.notes = data['notes'];
# persist the diagram, which will trigger the generation of a version
diagram.persist();
self.redirect( "/" + diagram.key().name() )
def get_all(
s,
*groups,
plot=False
): #could this be more efficient? maybe. returns members of all the intersections of n groups
for i, x in enumerate(groups):
if x.name is None:
x.name = i #need to fix this
names = [
frozenset(i) for i in Diagram.powerset([x.name for x in groups])
]
t = []
for i in s:
temp = []
for g in groups:
if i in g:
temp.append(g.name)
if temp:
t.append(frozenset(temp))
c = {i: 0 for i in names}
for i in t:
c[i] += 1
if not plot:
return c
Diagram.create_diagram(len(groups),
names=[x.name for x in groups],
quantities=c)
def notify(self, event):
"""G.notify (...) -> None
Notifies the Graph2D about an event.
"""
if not self.sensitive:
return
if event.signal in SIGNALS_MOUSE:
eventarea = self.rect_to_client()
if (event.signal == SIG_MOUSEDOWN) and \
eventarea.collidepoint (event.data.pos):
if event.data.button == 1:
self.focus = True
# Mouse wheel.
elif event.data.button == 4:
self.zoom_out()
elif event.data.button == 5:
self.zoom_in()
self.run_signal_handlers(SIG_MOUSEDOWN, event.data)
event.handled = True
elif (event.signal == SIG_DOUBLECLICKED):
eventarea = self.rect_to_client()
if eventarea.collidepoint(event.data.pos):
# The y origin starts at the bottom left, thus we have
# to invert the y value by using the height.
self.origin = event.data.pos[0] - eventarea.x, \
self.height - event.data.pos[1] + eventarea.y
self.run_signal_handlers(SIG_DOUBLECLICKED, event.data)
event.handled = True
elif self.focus and (event.signal == SIG_KEYDOWN):
# Zoom in and out.
if event.data.key in (K_PLUS, K_KP_PLUS):
self.zoom_in()
event.handled = True
elif event.data.key in (K_MINUS, K_KP_MINUS):
self.zoom_out()
event.handled = True
# Axis movement.
elif event.data.key == K_UP:
self.origin = (self.origin[0], self.origin[1] - 5)
event.handled = True
elif event.data.key == K_DOWN:
self.origin = (self.origin[0], self.origin[1] + 5)
event.handled = True
elif event.data.key == K_LEFT:
self.origin = (self.origin[0] + 5, self.origin[1])
event.handled = True
elif event.data.key == K_RIGHT:
self.origin = (self.origin[0] - 5, self.origin[1])
event.handled = True
Diagram.notify(self, event)
def notify (self, event):
"""G.notify (...) -> None
Notifies the Graph2D about an event.
"""
if not self.sensitive:
return
if event.signal in SIGNALS_MOUSE:
eventarea = self.rect_to_client ()
if (event.signal == SIG_MOUSEDOWN) and \
eventarea.collidepoint (event.data.pos):
if event.data.button == 1:
self.focus = True
# Mouse wheel.
elif event.data.button == 4:
self.zoom_out ()
elif event.data.button == 5:
self.zoom_in ()
self.run_signal_handlers (SIG_MOUSEDOWN, event.data)
event.handled = True
elif (event.signal == SIG_DOUBLECLICKED):
eventarea = self.rect_to_client ()
if eventarea.collidepoint (event.data.pos):
# The y origin starts at the bottom left, thus we have
# to invert the y value by using the height.
self.origin = event.data.pos[0] - eventarea.x, \
self.height - event.data.pos[1] + eventarea.y
self.run_signal_handlers (SIG_DOUBLECLICKED, event.data)
event.handled = True
elif self.focus and (event.signal == SIG_KEYDOWN):
# Zoom in and out.
if event.data.key in (K_PLUS, K_KP_PLUS):
self.zoom_in ()
event.handled = True
elif event.data.key in (K_MINUS, K_KP_MINUS):
self.zoom_out ()
event.handled = True
# Axis movement.
elif event.data.key == K_UP:
self.origin = (self.origin[0], self.origin[1] - 5)
event.handled = True
elif event.data.key == K_DOWN:
self.origin = (self.origin[0], self.origin[1] + 5)
event.handled = True
elif event.data.key == K_LEFT:
self.origin = (self.origin[0] + 5, self.origin[1])
event.handled = True
elif event.data.key == K_RIGHT:
self.origin = (self.origin[0] - 5, self.origin[1])
event.handled = True
Diagram.notify (self, event)
def get(self):
updated = Diagram.all().order('-updated').fetch(10);
viewed = Diagram.all().order('-viewCount').fetch(10);
template_values = {
'updated' : updated,
'viewed' : viewed
}
render_template( self, 'ListDiagrams', template_values )
def set_data(self, data):
"""G.set_data (...) -> None
Sets the data to evaluate.
Raises a TypeError, if the passed argument is not a list or tuple.
Raises a ValueError, if the passed argument values are not
integers or floats.
"""
if data != None:
if type(data) not in (list, tuple):
raise TypeError("data must be a list, tuple or array")
ov = filter(lambda x: type(x) not in (int, float), data)
if len(ov) != 0:
raise ValueError("vales in data must be integers or float")
Diagram.set_data(self, data)
def set_data (self, data):
"""G.set_data (...) -> None
Sets the data to evaluate.
Raises a TypeError, if the passed argument is not a list or tuple.
Raises a ValueError, if the passed argument values are not
integers or floats.
"""
if data != None:
if type (data) not in (list, tuple):
raise TypeError ("data must be a list, tuple or array")
ov = filter (lambda x: type (x) not in (int, float), data)
if len (ov) != 0:
raise ValueError ("vales in data must be integers or float")
Diagram.set_data (self, data)
def get(self):
key = self.request.path.replace("/", "")
diagram = Diagram.get(key)
if diagram:
template_values = {"diagram": diagram}
render_template(self, "ShowDiagram", template_values)
def test():
D = Diagram()
A = Object(D,"A")
AxA = Object(D,"AxA")
f = Morphism(AxA,A,)
g = Morphism(AxA,A)
ProductProperty(f,g)
RM = RuleMaster(D,prioritiser = UltimateWeightPriotiser)
for _ in xrange(10):
RM.rule(numberOfExtensions=3,verbose=True)
D.printCommutativity()
print D.Objects
#test()
#from cProfile import run
#run("test()")
def get_and_count_diagram(key, request, response):
diagram = Diagram.get(key);
seen = '';
if 'seen' in request.cookies: seen = request.cookies['seen'];
if not "/" + key + "/" in seen:
diagram.increase_view_count();
seen += "/" + key + "/";
response.headers.add_header( 'Set-Cookie','seen=' + seen + ';' );
return diagram;
def __init__(self, width, height):
Diagram.__init__(self)
# Some defaults.
self._zoom_factor = (1, 1)
self._units = (20, 20)
self._scaleunits = ("-", "-")
self._axes = ("x", "y")
self._shownames = True
# Colors.
self._axiscolor = (0, 0, 0)
self._graphcolor = (255, 0, 0)
# Signals.
self._signals[SIG_KEYDOWN] = []
self._signals[SIG_MOUSEDOWN] = []
self._signals[SIG_DOUBLECLICKED] = []
self.minsize = width, height
def abeliantest():
D = Diagram(category = AbelianCategory)
A = Object(D,"A")
B = Object(D,"B")
f = Morphism(A,B,"f")
#K = Object(D,"K")
#iker = Morphism(K,A,"ker_f")
#Kernel(f,iker)
C = Object(D,"C")
g = Morphism(C,A,"g")
SetEqualZero(f*g)
Rules = abelianRules+[ComposeRule,ExistIdentity]
RM = RuleMaster(D,Rules = Rules, prioritiser = UltimateWeightPriotiser)
for _ in xrange(40):
RM.rule(verbose=True)
D.printCommutativity()
def __init__ (self, width, height):
Diagram.__init__ (self)
# Some defaults.
self._zoom_factor = (1, 1)
self._units = (20, 20)
self._scaleunits = ("-", "-")
self._axes = ("x", "y")
self._shownames = True
# Colors.
self._axiscolor = (0, 0, 0)
self._graphcolor = (255, 0, 0)
# Signals.
self._signals[SIG_KEYDOWN] = []
self._signals[SIG_MOUSEDOWN] = []
self._signals[SIG_DOUBLECLICKED] = []
self.minsize = width, height
def draw(self):
"""W.draw () -> None
Draws the Graph2D surface.
Creates the visible surface of the Graph2D.
"""
Diagram.draw(self)
surface = self.image
rect = surface.get_rect()
# Orientation swapped?
swap = self.orientation == ORIENTATION_VERTICAL
# Coordinates.
origin = (rect.left + self.origin[0], rect.bottom - self.origin[1] - 1)
unitx = 1.0
unity = 1.0
if self.units and (len(self.units) > 1):
if self.orientation == ORIENTATION_VERTICAL:
unitx = self.units[1]
unity = self.units[0]
else:
unitx = self.units[0]
unity = self.units[1]
self._draw_axes(surface, rect, origin, unitx, unity)
data = self.data
values = self.values
if data and values:
# Filter negative values.
if not self.negative:
data = filter(lambda x: x >= 0, data)
values = filter(lambda y: y >= 0, values)
# Create the coordinate tuples and take the unit resolution into
# account.
coords = []
org0 = origin[0]
org1 = origin[1]
if self.orientation == ORIENTATION_VERTICAL:
coords = map(
lambda x, y: (int(org1 +
(x * unitx)), int(org0 + (y * unity))),
data, values)
else:
coords = map(
lambda x, y: (int(org0 +
(x * unitx)), int(org1 - (y * unity))),
data, values)
# Filter non-visible values.
width = self.width
height = self.height
coords = filter (lambda (x, y): (0 < x < width) and \
(0 < y < width), coords)
# Draw them.
color = self.graph_color
setat = surface.set_at
for xy in coords:
setat(xy, color)
def draw (self):
"""W.draw () -> None
Draws the Graph2D surface.
Creates the visible surface of the Graph2D.
"""
Diagram.draw (self)
surface = self.image
rect = surface.get_rect ()
# Orientation swapped?
swap = self.orientation == ORIENTATION_VERTICAL
# Coordinates.
origin = (rect.left + self.origin[0],
rect.bottom - self.origin[1] - 1)
unitx = 1.0
unity = 1.0
if self.units and (len (self.units) > 1):
if self.orientation == ORIENTATION_VERTICAL:
unitx = self.units[1]
unity = self.units[0]
else:
unitx = self.units[0]
unity = self.units[1]
self._draw_axes (surface, rect, origin, unitx, unity)
data = self.data
values = self.values
if data and values:
# Filter negative values.
if not self.negative:
data = filter (lambda x: x >= 0, data)
values = filter (lambda y: y >= 0, values)
# Create the coordinate tuples and take the unit resolution into
# account.
coords = []
org0 = origin[0]
org1 = origin[1]
if self.orientation == ORIENTATION_VERTICAL:
coords = map (lambda x, y: (int (org1 + (x * unitx)),
int (org0 + (y * unity))),
data, values)
else:
coords = map (lambda x, y: (int (org0 + (x * unitx)),
int (org1 - (y * unity))),
data, values)
# Filter non-visible values.
width = self.width
height = self.height
coords = filter (lambda (x, y): (0 < x < width) and \
(0 < y < width), coords)
# Draw them.
color = self.graph_color
setat = surface.set_at
for xy in coords:
setat (xy, color)
