bee_python 0.0.1

data/tools/common/common/tree.py

@@ -0,0 +1,372 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""Base class to represent a tree structure.
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+
+import sys
+
+from logilab.common import flatten
+from logilab.common.visitor import VisitedMixIn, FilteredIterator, no_filter
+
+## Exceptions #################################################################
+
+class NodeNotFound(Exception):
+    """raised when a node has not been found"""
+
+EX_SIBLING_NOT_FOUND = "No such sibling as '%s'"
+EX_CHILD_NOT_FOUND = "No such child as '%s'"
+EX_NODE_NOT_FOUND = "No such node as '%s'"
+
+
+# Base node ###################################################################
+
+class Node(object):
+    """a basic tree node, characterized by an id"""
+
+    def __init__(self, nid=None) :
+        self.id = nid
+        # navigation
+        self.parent = None
+        self.children = []
+
+    def __iter__(self):
+        return iter(self.children)
+
+    def __str__(self, indent=0):
+        s = ['%s%s %s' % (' '*indent, self.__class__.__name__, self.id)]
+        indent += 2
+        for child in self.children:
+            try:
+                s.append(child.__str__(indent))
+            except TypeError:
+                s.append(child.__str__())
+        return '\n'.join(s)
+
+    def is_leaf(self):
+        return not self.children
+
+    def append(self, child):
+        """add a node to children"""
+        self.children.append(child)
+        child.parent = self
+
+    def remove(self, child):
+        """remove a child node"""
+        self.children.remove(child)
+        child.parent = None
+
+    def insert(self, index, child):
+        """insert a child node"""
+        self.children.insert(index, child)
+        child.parent = self
+
+    def replace(self, old_child, new_child):
+        """replace a child node with another"""
+        i = self.children.index(old_child)
+        self.children.pop(i)
+        self.children.insert(i, new_child)
+        new_child.parent = self
+
+    def get_sibling(self, nid):
+        """return the sibling node that has given id"""
+        try:
+            return self.parent.get_child_by_id(nid)
+        except NodeNotFound :
+            raise NodeNotFound(EX_SIBLING_NOT_FOUND % nid)
+
+    def next_sibling(self):
+        """
+        return the next sibling for this node if any
+        """
+        parent = self.parent
+        if parent is None:
+            # root node has no sibling
+            return None
+        index = parent.children.index(self)
+        try:
+            return parent.children[index+1]
+        except IndexError:
+            return None
+
+    def previous_sibling(self):
+        """
+        return the previous sibling for this node if any
+        """
+        parent = self.parent
+        if parent is None:
+            # root node has no sibling
+            return None
+        index = parent.children.index(self)
+        if index > 0:
+            return parent.children[index-1]
+        return None
+
+    def get_node_by_id(self, nid):
+        """
+        return node in whole hierarchy that has given id
+        """
+        root = self.root()
+        try:
+            return root.get_child_by_id(nid, 1)
+        except NodeNotFound :
+            raise NodeNotFound(EX_NODE_NOT_FOUND % nid)
+
+    def get_child_by_id(self, nid, recurse=None):
+        """
+        return child of given id
+        """
+        if self.id == nid:
+            return self
+        for c in self.children :
+            if recurse:
+                try:
+                    return c.get_child_by_id(nid, 1)
+                except NodeNotFound :
+                    continue
+            if c.id == nid :
+                return c
+        raise NodeNotFound(EX_CHILD_NOT_FOUND % nid)
+
+    def get_child_by_path(self, path):
+        """
+        return child of given path (path is a list of ids)
+        """
+        if len(path) > 0 and path[0] == self.id:
+            if len(path) == 1 :
+                return self
+            else :
+                for c in self.children :
+                    try:
+                        return c.get_child_by_path(path[1:])
+                    except NodeNotFound :
+                        pass
+        raise NodeNotFound(EX_CHILD_NOT_FOUND % path)
+
+    def depth(self):
+        """
+        return depth of this node in the tree
+        """
+        if self.parent is not None:
+            return 1 + self.parent.depth()
+        else :
+            return 0
+
+    def depth_down(self):
+        """
+        return depth of the tree from this node
+        """
+        if self.children:
+            return 1 + max([c.depth_down() for c in self.children])
+        return 1
+
+    def width(self):
+        """
+        return the width of the tree from this node
+        """
+        return len(self.leaves())
+
+    def root(self):
+        """
+        return the root node of the tree
+        """
+        if self.parent is not None:
+            return self.parent.root()
+        return self
+
+    def leaves(self):
+        """
+        return a list with all the leaves nodes descendant from this node
+        """
+        leaves = []
+        if self.children:
+            for child in self.children:
+                leaves += child.leaves()
+            return leaves
+        else:
+            return [self]
+
+    def __iter__(self):
+        return iter(self.children)
+
+    def flatten(self, _list=None):
+        """
+        return a list with all the nodes descendant from this node
+        """
+        if _list is None:
+            _list = []
+        _list.append(self)
+        for c in self.children:
+            c.flatten(_list)
+        return _list
+
+    def lineage(self):
+        """
+        return list of parents up to root node
+        """
+        lst = [self]
+        if self.parent is not None:
+            lst.extend(self.parent.lineage())
+        return lst
+
+class VNode(Node, VisitedMixIn):
+    """a visitable node
+    """
+    pass
+
+
+class BinaryNode(VNode):
+    """a binary node (i.e. only two children
+    """
+    def __init__(self, lhs=None, rhs=None) :
+        VNode.__init__(self)
+        if lhs is not None or rhs is not None:
+            assert lhs and rhs
+            self.append(lhs)
+            self.append(rhs)
+
+    def remove(self, child):
+        """remove the child and replace this node with the other child
+        """
+        self.children.remove(child)
+        self.parent.replace(self, self.children[0])
+
+    def get_parts(self):
+        """
+        return the left hand side and the right hand side of this node
+        """
+        return self.children[0], self.children[1]
+
+
+
+if sys.version_info[0:2] >= (2, 2):
+    list_class = list
+else:
+    from UserList import UserList
+    list_class = UserList
+
+class ListNode(VNode, list_class):
+    """Used to manipulate Nodes as Lists
+    """
+    def __init__(self):
+        list_class.__init__(self)
+        VNode.__init__(self)
+        self.children = self
+
+    def __str__(self, indent=0):
+        return '%s%s %s' % (indent*' ', self.__class__.__name__,
+                            ', '.join([str(v) for v in self]))
+
+    def append(self, child):
+        """add a node to children"""
+        list_class.append(self, child)
+        child.parent = self
+
+    def insert(self, index, child):
+        """add a node to children"""
+        list_class.insert(self, index, child)
+        child.parent = self
+
+    def remove(self, child):
+        """add a node to children"""
+        list_class.remove(self, child)
+        child.parent = None
+
+    def pop(self, index):
+        """add a node to children"""
+        child = list_class.pop(self, index)
+        child.parent = None
+
+    def __iter__(self):
+        return list_class.__iter__(self)
+
+# construct list from tree ####################################################
+
+def post_order_list(node, filter_func=no_filter):
+    """
+    create a list with tree nodes for which the <filter> function returned true
+    in a post order fashion
+    """
+    l, stack = [], []
+    poped, index = 0, 0
+    while node:
+        if filter_func(node):
+            if node.children and not poped:
+                stack.append((node, index))
+                index = 0
+                node = node.children[0]
+            else:
+                l.append(node)
+                index += 1
+                try:
+                    node = stack[-1][0].children[index]
+                except IndexError:
+                    node = None
+        else:
+            node = None
+        poped = 0
+        if node is None and stack:
+            node, index = stack.pop()
+            poped = 1
+    return l
+
+def pre_order_list(node, filter_func=no_filter):
+    """
+    create a list with tree nodes for which the <filter> function returned true
+    in a pre order fashion
+    """
+    l, stack = [], []
+    poped, index = 0, 0
+    while node:
+        if filter_func(node):
+            if not poped:
+                l.append(node)
+            if node.children and not poped:
+                stack.append((node, index))
+                index = 0
+                node = node.children[0]
+            else:
+                index += 1
+                try:
+                    node = stack[-1][0].children[index]
+                except IndexError:
+                    node = None
+        else:
+            node = None
+        poped = 0
+        if node is None and len(stack) > 1:
+            node, index = stack.pop()
+            poped = 1
+    return l
+
+class PostfixedDepthFirstIterator(FilteredIterator):
+    """a postfixed depth first iterator, designed to be used with visitors
+    """
+    def __init__(self, node, filter_func=None):
+        FilteredIterator.__init__(self, node, post_order_list, filter_func)
+
+class PrefixedDepthFirstIterator(FilteredIterator):
+    """a prefixed depth first iterator, designed to be used with visitors
+    """
+    def __init__(self, node, filter_func=None):
+        FilteredIterator.__init__(self, node, pre_order_list, filter_func)
+

data/tools/common/common/umessage.py

@@ -0,0 +1,161 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""Unicode email support (extends email from stdlib).
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+
+import email
+from encodings import search_function
+from email.Utils import parseaddr, parsedate
+from email.Header import decode_header
+from datetime import datetime
+
+try:
+    from mx.DateTime import DateTime
+except ImportError:
+    DateTime = datetime
+
+import logilab.common as lgc
+
+
+def decode_QP(string):
+    parts = []
+    for decoded, charset in decode_header(string):
+        if not charset :
+            charset = 'iso-8859-15'
+        parts.append(unicode(decoded, charset, 'replace'))
+
+    return u' '.join(parts)
+
+def message_from_file(fd):
+    try:
+        return UMessage(email.message_from_file(fd))
+    except email.Errors.MessageParseError:
+        return ''
+
+def message_from_string(string):
+    try:
+        return UMessage(email.message_from_string(string))
+    except email.Errors.MessageParseError:
+        return ''
+
+class UMessage:
+    """Encapsulates an email.Message instance and returns only unicode objects.
+    """
+
+    def __init__(self, message):
+        self.message = message
+
+    # email.Message interface #################################################
+
+    def get(self, header, default=None):
+        value = self.message.get(header, default)
+        if value:
+            return decode_QP(value)
+        return value
+
+    def get_all(self, header, default=()):
+        return [decode_QP(val) for val in self.message.get_all(header, default)
+                if val is not None]
+
+    def get_payload(self, index=None, decode=False):
+        message = self.message
+        if index is None:
+            payload = message.get_payload(index, decode)
+            if isinstance(payload, list):
+                return [UMessage(msg) for msg in payload]
+            if message.get_content_maintype() != 'text':
+                return payload
+
+            charset = message.get_content_charset() or 'iso-8859-1'
+            if search_function(charset) is None:
+                charset = 'iso-8859-1'
+            return unicode(payload or '', charset, "replace")
+        else:
+            payload = UMessage(message.get_payload(index, decode))
+        return payload
+
+    def is_multipart(self):
+        return self.message.is_multipart()
+
+    def get_boundary(self):
+        return self.message.get_boundary()
+
+    def walk(self):
+        for part in self.message.walk():
+            yield UMessage(part)
+
+    def get_content_maintype(self):
+        return unicode(self.message.get_content_maintype())
+
+    def get_content_type(self):
+        return unicode(self.message.get_content_type())
+
+    def get_filename(self, failobj=None):
+        value = self.message.get_filename(failobj)
+        if value is failobj:
+            return value
+        try:
+            return unicode(value)
+        except UnicodeDecodeError:
+            return u'error decoding filename'
+
+    # other convenience methods ###############################################
+
+    def headers(self):
+        """return an unicode string containing all the message's headers"""
+        values = []
+        for header in self.message.keys():
+            values.append(u'%s: %s' % (header, self.get(header)))
+        return '\n'.join(values)
+
+    def multi_addrs(self, header):
+        """return a list of 2-uple (name, address) for the given address (which
+        is expected to be an header containing address such as from, to, cc...)
+        """
+        persons = []
+        for person in self.get_all(header, ()):
+            name, mail = parseaddr(person)
+            persons.append((name, mail))
+        return persons
+
+    def date(self, alternative_source=False, return_str=False):
+        """return a datetime object for the email's date or None if no date is
+        set or if it can't be parsed
+        """
+        value = self.get('date')
+        if value is None and alternative_source:
+            unix_from = self.message.get_unixfrom()
+            if unix_from is not None:
+                try:
+                    value = unix_from.split(" ", 2)[2]
+                except IndexError:
+                    pass
+        if value is not None:
+            datetuple = parsedate(value)
+            if datetuple:
+                if lgc.USE_MX_DATETIME:
+                    return DateTime(*datetuple[:6])
+                return datetime(*datetuple[:6])
+            elif not return_str:
+                return None
+        return value

data/tools/common/common/ureports/__init__.py

@@ -0,0 +1,174 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""Universal report objects and some formatting drivers.
+
+A way to create simple reports using python objects, primarily designed to be
+formatted as text and html.
+"""
+from __future__ import generators
+__docformat__ = "restructuredtext en"
+
+import sys
+from cStringIO import StringIO
+from StringIO import StringIO as UStringIO
+
+from logilab.common.textutils import linesep
+
+
+def get_nodes(node, klass):
+    """return an iterator on all children node of the given klass"""
+    for child in node.children:
+        if isinstance(child, klass):
+            yield child
+        # recurse (FIXME: recursion controled by an option)
+        for grandchild in get_nodes(child, klass):
+            yield grandchild
+
+def layout_title(layout):
+    """try to return the layout's title as string, return None if not found
+    """
+    for child in layout.children:
+        if isinstance(child, Title):
+            return ' '.join([node.data for node in get_nodes(child, Text)])
+
+def build_summary(layout, level=1):
+    """make a summary for the report, including X level"""
+    assert level > 0
+    level -= 1
+    summary = List(klass='summary')
+    for child in layout.children:
+        if not isinstance(child, Section):
+            continue
+        label = layout_title(child)
+        if not label and not child.id:
+            continue
+        if not child.id:
+            child.id = label.replace(' ', '-')
+        node = Link('#'+child.id, label=label or child.id)
+        # FIXME: Three following lines produce not very compliant
+        # docbook: there are some useless <para><para>. They might be
+        # replaced by the three commented lines but this then produces
+        # a bug in html display...
+        if level and [n for n in child.children if isinstance(n, Section)]:
+            node = Paragraph([node, build_summary(child, level)])
+        summary.append(node)
+#         summary.append(node)
+#         if level and [n for n in child.children if isinstance(n, Section)]:
+#             summary.append(build_summary(child, level))
+    return summary
+
+
+class BaseWriter(object):
+    """base class for ureport writers"""
+
+    def format(self, layout, stream=None, encoding=None):
+        """format and write the given layout into the stream object
+
+        unicode policy: unicode strings may be found in the layout;
+        try to call stream.write with it, but give it back encoded using
+        the given encoding if it fails
+        """
+        if stream is None:
+            stream = sys.stdout
+        if not encoding:
+            encoding = getattr(stream, 'encoding', 'UTF-8')
+        self.encoding = encoding or 'UTF-8'
+        self.__compute_funcs = []
+        self.out = stream
+        self.begin_format(layout)
+        layout.accept(self)
+        self.end_format(layout)
+
+    def format_children(self, layout):
+        """recurse on the layout children and call their accept method
+        (see the Visitor pattern)
+        """
+        for child in getattr(layout, 'children', ()):
+            child.accept(self)
+
+    def writeln(self, string=''):
+        """write a line in the output buffer"""
+        self.write(string + linesep)
+
+    def write(self, string):
+        """write a string in the output buffer"""
+        try:
+            self.out.write(string)
+        except UnicodeEncodeError:
+            self.out.write(string.encode(self.encoding))
+
+    def begin_format(self, layout):
+        """begin to format a layout"""
+        self.section = 0
+
+    def end_format(self, layout):
+        """finished to format a layout"""
+
+    def get_table_content(self, table):
+        """trick to get table content without actually writing it
+
+        return an aligned list of lists containing table cells values as string
+        """
+        result = [[]]
+        cols = table.cols
+        for cell in self.compute_content(table):
+            if cols == 0:
+                result.append([])
+                cols = table.cols
+            cols -= 1
+            result[-1].append(cell)
+        # fill missing cells
+        while len(result[-1]) < cols:
+            result[-1].append('')
+        return result
+
+    def compute_content(self, layout):
+        """trick to compute the formatting of children layout before actually
+        writing it
+
+        return an iterator on strings (one for each child element)
+        """
+        # use cells !
+        def write(data):
+            try:
+                stream.write(data)
+            except UnicodeEncodeError:
+                stream.write(data.encode(self.encoding))
+        def writeln(data=''):
+            try:
+                stream.write(data+linesep)
+            except UnicodeEncodeError:
+                stream.write(data.encode(self.encoding)+linesep)
+        self.write = write
+        self.writeln = writeln
+        self.__compute_funcs.append((write, writeln))
+        for child in layout.children:
+            stream = UStringIO()
+            child.accept(self)
+            yield stream.getvalue()
+        self.__compute_funcs.pop()
+        try:
+            self.write, self.writeln = self.__compute_funcs[-1]
+        except IndexError:
+            del self.write
+            del self.writeln
+
+
+from logilab.common.ureports.nodes import *
+from logilab.common.ureports.text_writer import TextWriter
+from logilab.common.ureports.html_writer import HTMLWriter