pynotebook 0.4.0__py3-none-any.whl

pynotebook/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

pynotebook/cerealizerformat.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+
+# cerealizerformat.py
+#
+# The former file format, based on cerealizer (a secure form of
+# pickling). Kept to load older files; jsonformat is the default. The
+# classes are those registered in jsonformat.
+
+from . import nbtexels, jsonformat
+from .textmodel import textmodel
+from .textmodel import texeltree, styles
+from .nbtexels import mk_textmodel
+
+import cerealizer
+from io import BytesIO
+
+
+magic = b'pynotebook0'
+cmagic =b'cereal1'
+
+def _register_classes():
+    # Classes are registered by their short name (cerealizer's default
+    # is module + name), because classes may move to other modules.
+    for classname, Class in jsonformat.get_registered():
+        try:
+            cerealizer.register(Class, None, classname)
+        except ValueError: # already registered
+            pass
+
+
+def dumps(obj):
+    _register_classes()
+    s = BytesIO()
+    cerealizer.Dumper().dump(obj, s)
+    c = s.getvalue()
+    assert c.startswith(cmagic)
+    return magic+c[len(cmagic):]
+
+
+def _replace_styles(texel, table):
+    if texel.is_group or texel.is_container:
+        for child in texel.childs:
+            _replace_styles(child, table)
+    else:
+        if 'style' in texel.__dict__:
+            sid = id(texel.style)
+            if not sid in table:
+                table[sid] = styles.create_style(**texel.style)
+            texel.style = table[sid]
+        if isinstance(texel, texeltree.NewLine) and 'parstyle' in texel.__dict__:
+            sid = id(texel.parstyle)
+            if not sid in table:
+                table[sid] = texel.parstyle = styles.create_style(**texel.parstyle)
+            texel.parstyle = table[sid]
+
+def loads(s):
+    assert s.startswith(magic)
+    _register_classes()
+    s = cmagic+s[len(magic):]
+    
+    model =  cerealizer.Dumper().undump(BytesIO(s))
+    _replace_styles(model.texel, {})
+    return model
+
+
+
+def test_00():
+    model1 = textmodel.TextModel()
+    tmp = textmodel.TextModel(u'for a in range(5):\n    print a')
+    cell = nbtexels.ScriptingCell(tmp.texel, texeltree.NULL_TEXEL)
+    model1.insert(len(model1), mk_textmodel(cell))
+
+    s = dumps(model1)
+    model2 = loads(s)
+    assert str(model1.texel) == str(model2.texel)
+    assert model1.get_style(5) is model2.get_style(5)
+    assert model1.get_parstyle(5) is model2.get_parstyle(5)

pynotebook/clients.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+
+
+
+class Aborted(Exception):
+    pass
+
+
+class Client:
+    name = 'unnamed' # each client should have a unique name 
+    counter = 0
+    can_abort = False # not all clients can abort
+
+    def abort(self):
+        pass
+
+    def execute(self, texel):
+        """Returns a tuple of completions. """
+        pass
+
+    def complete(self, word, nmax=None):
+        """Returns a tuple of completions. """
+        pass
+
+    def colorize(self, texel, styles=None, bgcolor='white'):
+        """Colorizes $texel$ to make it more readable. """
+        return texel
+
+
+
+class ClientPool:
+    def __init__(self):
+        self.clients = {}
+
+    def add(self, client, name):
+        self.clients[name] = client
+        
+    def register(self, client):
+        self.add(client, client.name)
+
+    def get(self, name):
+        return self.clients[name]
+    
+    def get_matching(self, texel):
+        return self.get(texel.client_name)
+

pynotebook/controlled.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# log method calls which lead to exceptions
+
+import os
+import sys
+import traceback
+import cPickle
+from tempfile import mkdtemp
+
+bk_stderr = sys.stderr
+
+def store_exception(obj, name, args, kwds):
+    dirname = mkdtemp(prefix="pnb_tmp")
+    tb = traceback.format_exc()
+    f = open(os.path.join(dirname, 'exception.txt'), 'wb')
+    print >>f, tb
+    f = open(os.path.join(dirname, 'call.pickle'), 'wb')
+    l = (obj, name, args, kwds)
+    cPickle.dump(l, f)
+    print >>bk_stderr, tb
+    print >>bk_stderr, "Stored details to file %s" % repr(dirname)
+
+
+    
+def controlled(f):
+    def new_f(self, *args, **kwds):
+        try:
+            return f(self, *args, **kwds)
+        except:
+            store_exception(self.model, f.__name__, args, kwds)
+            raise
+    return new_f
+
+
+
+
+

pynotebook/graphics.py

@@ -0,0 +1,414 @@
+# -*- coding: utf-8 -*-
+
+#
+# graphics.py
+#
+#
+# This module defines graphics operations which are used in connection
+# with the 'Graphics'-Texel. Each instance of an operations definies a
+# certain graphical object (e.g. a line or circle) or sets certain
+# drawing properties (.e.g. line color or fill color).
+#
+# Lists of graphic operations represent a vector graphic. They can be
+# saved, loaded or displayed.
+
+
+# XXX missing: 
+# - SetLogicalFunction
+# - fill styles
+# - gradient fills
+# - rounded rectangle
+# - clipping
+# - spline
+
+
+import wx
+from .nbtexels import Graphics
+
+
+
+def _normalize_color(color):
+    if isinstance(color, wx.Colour):
+        return color.asTuple()+(color.Alpha(), )
+    elif isinstance(color, str):
+        c = wx.Colour(color)
+        return tuple(c)
+    elif type(color) in (list, tuple) and len(color) in (3, 4):        
+        return tuple(color)
+    else:
+        raise ValueError('Not a valid color specification: %s' % repr(color))
+
+
+# Some versions of wx (accidentally) use degrees instead of
+# radians. The following factor is used to correct this. It has the
+# value None and is set later to either 1.0 or pi/180.0
+#
+# Calculation is could be done here in principle, using a
+# MeasuringContext. However, this always gives memory violations.
+_rotation_correction = None
+
+
+    
+class LineColor:
+    def __init__(self, color):
+        self.color = _normalize_color(color)
+        
+    def draw(self, gc, state):
+        pen = state["pen"]
+        pen.SetColour(self.color)
+        gc.SetPen(pen)
+
+
+class LineWidth:
+    def __init__(self, width):
+        self.width = width
+        
+    def draw(self, gc, state):
+        pen = state["pen"]
+        pen.SetWidth(self.width)
+        gc.SetPen(pen)
+
+
+class LineDashes:
+    # Dashes is a list of length values. Example: [5, 5] will draw a
+    # line of length 5, a space of length 5, a line of length 5, ...
+    def __init__(self, dashes):
+        self.dashes = dashes
+        
+    def draw(self, gc, state):
+        pen = state["pen"]
+        pen.SetDashes(self.dashes)
+        gc.SetPen(pen)
+
+line_joins = dict(
+    bevel=wx.JOIN_BEVEL, miter=wx.JOIN_MITER, round=wx.JOIN_ROUND)
+
+class LineJoin:
+    def __init__(self, join_style):
+        if not join_style in line_joins:
+            raise ValueError("join_style mus be 'bevel, 'miter or 'round'")
+        self.join_style = join_style
+        
+    def draw(self, gc, state):
+        pen = state["pen"]
+        pen.SetJoin(line_joins[self.join_style])
+        gc.SetPen(pen)
+
+
+line_caps = dict(
+    round=wx.CAP_ROUND, projecting=wx.CAP_PROJECTING, butt=wx.CAP_BUTT)
+
+class LineCap:
+    def __init__(self, cap_style):
+        if not cap_style in line_caps:
+            raise ValueError("cap_style mus be 'round', 'projecting' or 'butt'")
+        self.cap_style = cap_style
+        
+    def draw(self, gc, state):
+        pen = state["pen"]
+        pen.SetCap(line_caps[self.cap_style])
+        gc.SetPen(pen)
+
+        
+class FillColor:
+    def __init__(self, color):
+        self.color = _normalize_color(color)
+        
+    def draw(self, gc, state):
+        brush = state["brush"]
+        brush.SetColour(self.color)
+        brush.SetStyle(wx.SOLID)
+        gc.SetBrush(brush) 
+
+
+class Line:
+    def __init__(self, *points):
+        self.points = tuple(points)
+
+    def draw(self, gc, state):
+        points = self.points
+        if len(points)<2:
+            return
+        p = gc.CreatePath()
+        for point in points:
+            p.AddLineToPoint(point)
+        p.Transform(state['matrix'])
+        gc.DrawPath(p)
+
+
+# class Spline:
+#     def __init__(self, *points):
+#         self.points = tuple(points)
+#
+#     def draw(self, gc, state):
+#         gc.DrawSpline(self.points)
+#         # XXX TODO
+
+
+class Polygon:
+    def __init__(self, *points):
+        self.points = tuple(points)
+        # XXX should we be able to set the fill rule?
+
+    def draw(self, gc, state):
+        points = self.points
+        if len(points)<2:
+            return
+        p = gc.CreatePath()
+        for point in points:
+            p.AddLineToPoint(point)
+        p.CloseSubpath()
+        p.Transform(state['matrix'])
+        gc.DrawPath(p)
+
+
+        
+class Path:
+    """A path represents shapes like lines, curves, arcs and more.
+
+*data* ist a list of drawing commands which are each specified as
+ tuples with coordinate values. Currently there are four commands: 
+  - M (move to point)
+  - L (line to point)
+  - Q (Bezier curve to point)
+  - Z (close path)
+    """
+    def __init__(self, *data):
+        self.data = data
+        
+    def draw(self, gc, state):
+        wxpath = gc.CreatePath()
+        x = y = 0
+        for item in self.data:
+            cmd = item[0]
+            points = item[1:]
+            if cmd == 'M':
+                x, y = points
+                wxpath.MoveToPoint(x, y)
+            elif cmd == 'L':
+                x, y = points
+                wxpath.AddLineToPoint(x, y)
+            elif cmd == 'Q':
+                cx, cy, x, y = points
+                wxpath.AddQuadCurveToPoint(cx, cy, x, y)
+            elif cmd == 'Z':
+                wxpath.CloseSubpath()
+            else:
+                raise Exception("Unknown path command: '%s'" % cmd)
+        wxpath.Transform(state['matrix'])            
+        gc.DrawPath(wxpath)
+
+
+
+    
+class Circle:
+    def __init__(self, xxx_todo_changeme1, r):
+        (x, y) = xxx_todo_changeme1
+        self.x = x
+        self.y = y
+        self.r = r
+        
+    def draw(self, gc, state):
+        p = gc.CreatePath()
+        p.AddCircle(self.x, self.y, self.r)
+        p.Transform(state['matrix'])
+        gc.DrawPath(p)
+
+
+class Ellipse:
+    def __init__(self, xxx_todo_changeme2, r1, r2):
+        (x, y) = xxx_todo_changeme2
+        self.x = x
+        self.y = y
+        self.r1 = r1
+        self.r2 = r2
+        
+    def draw(self, gc, state):
+        p = gc.CreatePath()
+        p.AddEllipse(self.x, self.y, self.r1, self.r2)
+        p.Transform(state['matrix'])
+        gc.DrawPath(p)
+
+        
+
+class Arc:
+    def __init__(self, xxx_todo_changeme3, r, start, end):
+        (x, y) = xxx_todo_changeme3
+        self.x = x
+        self.y = y
+        self.r = r
+        self.start = start
+        self.end = end
+        # XXX do we need clockwise?
+        
+    def draw(self, gc, state):
+        p = gc.CreatePath()
+        p.AddArc(self.x, self.y, self.r, self.start, self.end, True)
+        p.Transform(state['matrix'])
+        gc.DrawPath(p)
+
+
+
+class Rectangle:
+    def __init__(self, xxx_todo_changeme4, xxx_todo_changeme5):
+        (x1, y1) = xxx_todo_changeme4
+        (x2, y2) = xxx_todo_changeme5
+        self.x1 = x1
+        self.y1 = y1
+        self.x2 = x2
+        self.y2 = y2
+        
+    def draw(self, gc, state):
+        x = min(self.x1, self.x2)
+        w = max(self.x1, self.x2)-x
+        y = min(self.y1, self.y2)
+        h = max(self.y1, self.y2)-y        
+        p = gc.CreatePath()
+        p.AddRectangle(x, y, w, h)
+        p.Transform(state['matrix'])
+        gc.DrawPath(p)
+
+        
+
+class Font:
+    def __init__(self, size, family, style, weight, 
+                 underline=False, face="", 
+                 encoding=wx.FONTENCODING_DEFAULT):
+        self.size = size
+        self.family = family
+        self.style = style
+        self.weight = weight
+        self.underline = underline
+        self.face = face
+        self.encoding = encoding
+        
+    def draw(self, gc, state):
+        font = wx.Font(self.size, self.family, self.style,
+                       self.weight, self.underline, 
+                       self.face, self.encoding)
+        gc.SetFont(font)
+
+
+class GraphicsText:
+    def __init__(self, text, point, align=(0, 0)):
+        self.text = text
+        self.point = point
+        self.align = align
+        
+    def draw(self, gc, state):
+        x, y = self.point
+        w, h = gc.GetTextExtent(self.text)
+        dx = 0.5*w*(self.align[0]-1)
+        dy = 0.5*h*(self.align[1]-1)
+        gc.SetTransform(state['matrix'])
+        gc.DrawText(self.text, x+dx, y+dy)
+        gc.SetTransform(state['trafo'])
+
+Text = GraphicsText # alias
+
+
+class Translate:
+    def __init__(self, offset):
+        self.offset = offset
+        
+    def draw(self, gc, state):
+        dx, dy = self.offset
+        state['matrix'].Translate(dx, dy) 
+        #gc.Translate(dx, dy)
+
+
+class Rotate:
+    def __init__(self, angle):
+        self.angle = angle
+        
+    def draw(self, gc, state):
+        global _rotation_correction
+        if _rotation_correction is None:
+            # Determine rotation correction factor.
+            m = gc.CreateMatrix()
+            m.Rotate(360)
+            if m.Get()[0]<-0.28:
+                # radians
+                _rotation_correction = 1
+            else:
+                # degrees
+                import math
+                _rotation_correction = math.pi/180
+        else:
+            _rotation_correction = 1
+
+        state['matrix'].Rotate(self.angle*_rotation_correction) 
+
+
+class Scale:
+    def __init__(self, fx, fy=None):
+        if fy is None:
+            fy = fx
+        self.fx = fx
+        self.fy = fy
+        
+    def draw(self, gc, state):
+        state['matrix'].Scale(self.fx, self.fy)
+
+
+
+def _register_graphics_classes():
+    from .jsonformat import register
+    for value in list(globals().values()):
+        if isinstance(value, type) and value.__module__ == __name__:
+            register(value)
+
+_register_graphics_classes()
+
+
+def register_classes():
+    pass  # registration happens automatically on import
+
+
+def init_testing(redirect=True):
+    import wx
+    from .nbview import TextModel, NBView
+    app = wx.App(redirect=redirect)
+    model = TextModel('')
+
+    frame = wx.Frame(None)
+    win = wx.Panel(frame, -1)
+    view = NBView(win, -1, style=wx.SUNKEN_BORDER)
+    view.model = model
+    box = wx.BoxSizer(wx.VERTICAL)
+    box.Add(view, 1, wx.ALL|wx.GROW, 1)
+    win.SetSizer(box)
+    win.SetAutoLayout(True)
+
+    frame.Show()
+    return locals()
+
+def test_00():
+    "Graphics"
+    from .nbview import mk_textmodel
+    ns = init_testing(False)
+    model = ns['model']
+    model.insert(len(model), mk_textmodel(Graphics([Circle((0, 0), 5)])))
+    segments = [
+        (0, 0), (0, 10), (10, 10), (10, 0)
+    ]
+    l = Line(*segments)
+    model.insert(len(model), mk_textmodel(Graphics([l])))
+    return ns
+
+
+    
+def demo_00():
+    import wx
+    from .wxtextview import testing
+    ns = test_00()
+    testing.pyshell(ns)
+    py = ns['view']._clients._clients['direct python']
+    py.namespace.update(
+        dict(Graphics=Graphics, Dot=Dot, Line=Line))
+    ns['app'].MainLoop()
+
+
+
+
+