bee_python 0.0.3 → 0.0.4

data/tools/common/common/tree.py

@@ -1,372 +0,0 @@
-# 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

@@ -1,161 +0,0 @@
-# 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

@@ -1,174 +0,0 @@
-# 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