bee_python 0.0.3 → 0.0.4

data/tools/common/common/graph.py

@@ -1,259 +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/>.
-"""Graph manipulation utilities.
-
-(dot generation adapted from pypy/translator/tool/make_dot.py)
-
-
-
-
-"""
-__docformat__ = "restructuredtext en"
-
-__metaclass__ = type
-
-import os.path as osp
-import os
-import subprocess
-import sys
-import tempfile
-
-def escape(value):
-    """Make <value> usable in a dot file."""
-    lines = [line.replace('"', '\\"') for line in value.split('\n')]
-    data = '\\l'.join(lines)
-    return '\\n' + data
-
-def target_info_from_filename(filename):
-    """Transforms /some/path/foo.png into ('/some/path', 'foo.png', 'png')."""
-    basename = osp.basename(filename)
-    storedir = osp.dirname(osp.abspath(filename))
-    target = filename.split('.')[-1]
-    return storedir, basename, target
-
-
-class DotBackend:
-    """Dot File backend."""
-    def __init__(self, graphname, rankdir=None, size=None, ratio=None,
-            charset='utf-8', renderer='dot', additionnal_param={}):
-        self.graphname = graphname
-        self.renderer = renderer
-        self.lines = []
-        self._source = None
-        self.emit("digraph %s {" % normalize_node_id(graphname))
-        if rankdir:
-            self.emit('rankdir=%s' % rankdir)
-        if ratio:
-            self.emit('ratio=%s' % ratio)
-        if size:
-            self.emit('size="%s"' % size)
-        if charset:
-            assert charset.lower() in ('utf-8', 'iso-8859-1', 'latin1'), \
-                   'unsupported charset %s' % charset
-            self.emit('charset="%s"' % charset)
-        for param in additionnal_param.iteritems():
-            self.emit('='.join(param))
-
-    def get_source(self):
-        """returns self._source"""
-        if self._source is None:
-            self.emit("}\n")
-            self._source = '\n'.join(self.lines)
-            del self.lines
-        return self._source
-
-    source = property(get_source)
-
-    def generate(self, outputfile=None, dotfile=None, mapfile=None):
-        """Generates a graph file.
-
-        :param outputfile: filename and path [defaults to graphname.png]
-        :param dotfile: filename and path [defaults to graphname.dot]
-
-        :rtype: str
-        :return: a path to the generated file
-        """
-        name = self.graphname
-        if not dotfile:
-            # if 'outputfile' is a dot file use it as 'dotfile'
-            if outputfile and outputfile.endswith(".dot"):
-                dotfile = outputfile
-            else:
-                dotfile = '%s.dot' % name
-        if outputfile is not None:
-            storedir, basename, target = target_info_from_filename(outputfile)
-            if target != "dot":
-                pdot, dot_sourcepath = tempfile.mkstemp(".dot", name)
-                os.close(pdot)
-            else:
-                dot_sourcepath = osp.join(storedir, dotfile)
-        else:
-            target = 'png'
-            pdot, dot_sourcepath = tempfile.mkstemp(".dot", name)
-            ppng, outputfile = tempfile.mkstemp(".png", name)
-            os.close(pdot)
-            os.close(ppng)
-        pdot = open(dot_sourcepath,'w')
-        if isinstance(self.source, unicode):
-            pdot.write(self.source.encode('UTF8'))
-        else:
-            pdot.write(self.source)
-        pdot.close()
-        if target != 'dot':
-            if mapfile:
-                subprocess.call('%s -Tcmapx -o%s -T%s %s -o%s' % (self.renderer, mapfile,
-                           target, dot_sourcepath, outputfile), shell=True)
-            else:
-                subprocess.call('%s -T%s %s -o%s' % (self.renderer, target,
-                            dot_sourcepath, outputfile), shell=True)
-            os.unlink(dot_sourcepath)
-        return outputfile
-
-    def emit(self, line):
-        """Adds <line> to final output."""
-        self.lines.append(line)
-
-    def emit_edge(self, name1, name2, **props):
-        """emit an edge from <name1> to <name2>.
-        edge properties: see http://www.graphviz.org/doc/info/attrs.html
-        """
-        attrs = ['%s="%s"' % (prop, value) for prop, value in props.items()]
-        n_from, n_to = normalize_node_id(name1), normalize_node_id(name2)
-        self.emit('%s -> %s [%s];' % (n_from, n_to, ", ".join(attrs)) )
-
-    def emit_node(self, name, **props):
-        """emit a node with given properties.
-        node properties: see http://www.graphviz.org/doc/info/attrs.html
-        """
-        attrs = ['%s="%s"' % (prop, value) for prop, value in props.items()]
-        self.emit('%s [%s];' % (normalize_node_id(name), ", ".join(attrs)))
-
-def normalize_node_id(nid):
-    """Returns a suitable DOT node id for `nid`."""
-    return '"%s"' % nid
-
-class GraphGenerator:
-    def __init__(self, backend):
-        # the backend is responsible to output the graph in a particular format
-        self.backend = backend
-
-    def generate(self, visitor, propshdlr, outputfile=None, mapfile=None):
-        # the visitor
-        # the property handler is used to get node and edge properties
-        # according to the graph and to the backend
-        self.propshdlr = propshdlr
-        for nodeid, node in visitor.nodes():
-            props = propshdlr.node_properties(node)
-            self.backend.emit_node(nodeid, **props)
-        for subjnode, objnode, edge in visitor.edges():
-            props = propshdlr.edge_properties(edge, subjnode, objnode)
-            self.backend.emit_edge(subjnode, objnode, **props)
-        return self.backend.generate(outputfile=outputfile, mapfile=mapfile)
-
-
-class UnorderableGraph(Exception):
-    def __init__(self, cycles):
-        self.cycles = cycles
-
-    def __str__(self):
-        return 'cycles in graph: %s' % self.cycles
-
-def ordered_nodes(graph):
-    """takes a dependency graph dict as arguments and return an ordered tuple of
-    nodes starting with nodes without dependencies and up to the outermost node.
-
-    If there is some cycle in the graph, :exc:`UnorderableGraph` will be raised.
-
-    Also the given graph dict will be emptied.
-    """
-    cycles = get_cycles(graph)
-    if cycles:
-        cycles = '\n'.join(' -> '.join(cycle) for cycle in cycles)
-        raise UnorderableGraph(cycles)
-    ordered = []
-    while graph:
-        # sorted to get predictable results
-        for node, deps in sorted(graph.items()):
-            if not deps:
-                ordered.append(node)
-                del graph[node]
-                for deps in graph.itervalues():
-                    try:
-                        deps.remove(node)
-                    except KeyError:
-                        continue
-    return tuple(reversed(ordered))
-
-
-
-def get_cycles(graph_dict, vertices=None):
-    '''given a dictionary representing an ordered graph (i.e. key are vertices
-    and values is a list of destination vertices representing edges), return a
-    list of detected cycles
-    '''
-    if not graph_dict:
-        return ()
-    result = []
-    if vertices is None:
-        vertices = graph_dict.keys()
-    for vertice in vertices:
-        _get_cycles(graph_dict, vertice, [], result)
-    return result
-
-def _get_cycles(graph_dict, vertice=None, path=None, result=None):
-    """recursive function doing the real work for get_cycles"""
-    if vertice in path:
-        cycle = [vertice]
-        for node in path[::-1]:
-            if node == vertice:
-                break
-            cycle.insert(0, node)
-        # make a canonical representation
-        start_from = min(cycle)
-        index = cycle.index(start_from)
-        cycle = cycle[index:] + cycle[0:index]
-        # append it to result if not already in
-        if not cycle in result:
-            result.append(cycle)
-        return
-    path.append(vertice)
-    try:
-        for node in graph_dict[vertice]:
-            _get_cycles(graph_dict, node, path, result)
-    except KeyError:
-        pass
-    path.pop()
-
-def has_path(graph_dict, fromnode, tonode, path=None):
-    """generic function taking a simple graph definition as a dictionary, with
-    node has key associated to a list of nodes directly reachable from it.
-
-    Return None if no path exists to go from `fromnode` to `tonode`, else the
-    first path found (as a list including the destination node at last)
-    """
-    if path is None:
-        path = []
-    elif fromnode in path:
-        return None
-    path.append(fromnode)
-    for destnode in graph_dict[fromnode]:
-        if destnode == tonode or has_path(graph_dict, destnode, tonode, path):
-            return path[1:] + [tonode]
-    path.pop()
-    return None
-

data/tools/common/common/html.py

@@ -1,142 +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/>.
-"""render a tree in HTML.
-
-
-
-
-"""
-__docformat__ = "restructuredtext en"
-
-
-def render_HTML_tree(tree, selected_node=None, render_node=None, caption=None):
-    """
-    Generate a pure HTML representation of a tree given as an instance
-    of a logilab.common.tree.Node
-
-    selected_node is the currently selected node (if any) which will
-    have its surrounding <div> have id="selected" (which default
-    to a bold border libe with the default CSS).
-
-    render_node is a function that should take a Node content (Node.id)
-    as parameter and should return a string (what will be displayed
-    in the cell).
-
-    Warning: proper rendering of the generated html code depends on html_tree.css
-    """
-    tree_depth = tree.depth_down()
-    if render_node is None:
-        render_node = str
-
-    # helper function that build a matrix from the tree, like:
-    # +------+-----------+-----------+
-    # | root | child_1_1 | child_2_1 |
-    # | root | child_1_1 | child_2_2 |
-    # | root | child_1_2 |           |
-    # | root | child_1_3 | child_2_3 |
-    # | root | child_1_3 | child_2_4 |
-    # +------+-----------+-----------+
-    # from:
-    # root -+- child_1_1 -+- child_2_1
-    #       |             |
-    #       |             +- child_2_2
-    #       +- child_1_2
-    #       |
-    #       +- child1_3 -+- child_2_3
-    #                    |
-    #                    +- child_2_2
-    def build_matrix(path, matrix):
-        if path[-1].is_leaf():
-            matrix.append(path[:])
-        else:
-            for child in path[-1].children:
-                build_matrix(path[:] + [child], matrix)
-
-    matrix = []
-    build_matrix([tree], matrix)
-
-    # make all lines in the matrix have the same number of columns
-    for line in matrix:
-        line.extend([None]*(tree_depth-len(line)))
-    for i in range(len(matrix)-1, 0, -1):
-        prev_line, line = matrix[i-1:i+1]
-        for j in range(len(line)):
-            if line[j] == prev_line[j]:
-                line[j] = None
-
-    # We build the matrix of link types (between 2 cells on a line of the matrix)
-    # link types are :
-    link_types = {(True,  True,  True ): 1, # T
-                  (False, False, True ): 2, # |
-                  (False, True,  True ): 3, # + (actually, vert. bar with horiz. bar on the right)
-                  (False, True,  False): 4, # L
-                  (True,  True,  False): 5, # -
-                  }
-    links = []
-    for i, line in enumerate(matrix):
-        links.append([])
-        for j in range(tree_depth-1):
-            cell_11 = line[j] is not None
-            cell_12 = line[j+1] is not None
-            cell_21 = line[j+1] is not None and line[j+1].next_sibling() is not None
-            link_type = link_types.get((cell_11, cell_12, cell_21), 0)
-            if link_type == 0 and i > 0 and links[i-1][j] in (1, 2, 3):
-                link_type = 2
-            links[-1].append(link_type)
-
-
-    # We can now generate the HTML code for the <table>
-    s = u'<table class="tree">\n'
-    if caption:
-        s += '<caption>%s</caption>\n' % caption
-
-    for i, link_line in enumerate(links):
-        line = matrix[i]
-
-        s += '<tr>'
-        for j, link_cell in enumerate(link_line):
-            cell = line[j]
-            if cell:
-                if cell.id == selected_node:
-                    s += '<td class="tree_cell" rowspan="2"><div class="selected tree_cell">%s</div></td>' % (render_node(cell.id))
-                else:
-                    s += '<td class="tree_cell" rowspan="2"><div class="tree_cell">%s</div></td>' % (render_node(cell.id))
-            else:
-                s += '<td rowspan="2">&nbsp;</td>'
-            s += '<td class="tree_cell_%d_1">&nbsp;</td>' % link_cell
-            s += '<td class="tree_cell_%d_2">&nbsp;</td>' % link_cell
-
-        cell = line[-1]
-        if cell:
-            if cell.id == selected_node:
-                s += '<td class="tree_cell" rowspan="2"><div class="selected tree_cell">%s</div></td>' % (render_node(cell.id))
-            else:
-                s += '<td class="tree_cell" rowspan="2"><div class="tree_cell">%s</div></td>' % (render_node(cell.id))
-        else:
-            s += '<td rowspan="2">&nbsp;</td>'
-
-        s += '</tr>\n'
-        if link_line:
-            s += '<tr>'
-            for j, link_cell in enumerate(link_line):
-                s += '<td class="tree_cell_%d_3">&nbsp;</td>' % link_cell
-                s += '<td class="tree_cell_%d_4">&nbsp;</td>' % link_cell
-            s += '</tr>\n'
-
-    s += '</table>'
-    return s

data/tools/common/common/interface.py

@@ -1,76 +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/>.
-"""Bases class for interfaces to provide 'light' interface handling.
-
- TODO:
-  _ implements a check method which check that an object implements the
-    interface
-  _ Attribute objects
-
-  This module requires at least python 2.2
-
-
-
-
-"""
-__docformat__ = "restructuredtext en"
-
-from types import ListType, TupleType
-
-class Interface(object):
-    """Base class for interfaces."""
-    def is_implemented_by(cls, instance):
-        return implements(instance, cls)
-    is_implemented_by = classmethod(is_implemented_by)
-
-
-def implements(obj, interface):
-    """Return true if the give object (maybe an instance or class) implements
-    the interface.
-    """
-    kimplements = getattr(obj, '__implements__', ())
-    if not isinstance(kimplements, (list, tuple)):
-        kimplements = (kimplements,)
-    for implementedinterface in kimplements:
-        if issubclass(implementedinterface, interface):
-            return True
-    return False
-
-
-def extend(klass, interface, _recurs=False):
-    """Add interface to klass'__implements__ if not already implemented in.
-
-    If klass is subclassed, ensure subclasses __implements__ it as well.
-
-    NOTE: klass should be e new class.
-    """
-    if not implements(klass, interface):
-        try:
-            kimplements = klass.__implements__
-            kimplementsklass = type(kimplements)
-            kimplements = list(kimplements)
-        except AttributeError:
-            kimplementsklass = tuple
-            kimplements = []
-        kimplements.append(interface)
-        klass.__implements__ = kimplementsklass(kimplements)
-        for subklass in klass.__subclasses__():
-            extend(subklass, interface, _recurs=True)
-    elif _recurs:
-        for subklass in klass.__subclasses__():
-            extend(subklass, interface, _recurs=True)

data/tools/common/common/logging_ext.py

@@ -1,166 +0,0 @@
-# -*- coding: utf-8 -*-
-# 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/>.
-
-"""Extends the logging module from the standard library.
-
-
-
-
-"""
-__docformat__ = "restructuredtext en"
-
-import os
-import sys
-import logging
-
-from logilab.common.textutils import colorize_ansi
-
-
-def set_log_methods(cls, logger):
-    """bind standard logger's methods as methods on the class"""
-    cls.__logger = logger
-    for attr in ('debug', 'info', 'warning', 'error', 'critical', 'exception'):
-        setattr(cls, attr, getattr(logger, attr))
-
-
-def xxx_cyan(record):
-    if 'XXX' in record.message:
-        return 'cyan'
-
-class ColorFormatter(logging.Formatter):
-    """
-    A color Formatter for the logging standard module.
-
-    By default, colorize CRITICAL and ERROR in red, WARNING in orange, INFO in
-    green and DEBUG in yellow.
-
-    self.colors is customizable via the 'color' constructor argument (dictionary).
-
-    self.colorfilters is a list of functions that get the LogRecord
-    and return a color name or None.
-    """
-
-    def __init__(self, fmt=None, datefmt=None, colors=None):
-        logging.Formatter.__init__(self, fmt, datefmt)
-        self.colorfilters = []
-        self.colors = {'CRITICAL': 'red',
-                       'ERROR': 'red',
-                       'WARNING': 'magenta',
-                       'INFO': 'green',
-                       'DEBUG': 'yellow',
-                       }
-        if colors is not None:
-            assert isinstance(colors, dict)
-            self.colors.update(colors)
-
-    def format(self, record):
-        msg = logging.Formatter.format(self, record)
-        if record.levelname in self.colors:
-            color = self.colors[record.levelname]
-            return colorize_ansi(msg, color)
-        else:
-            for cf in self.colorfilters:
-                color = cf(record)
-                if color: 
-                    return colorize_ansi(msg, color)
-        return msg
-
-def set_color_formatter(logger=None, **kw):
-    """
-    Install a color formatter on the 'logger'. If not given, it will
-    defaults to the default logger.
-
-    Any additional keyword will be passed as-is to the ColorFormatter
-    constructor.
-    """
-    if logger is None:
-        logger = logging.getLogger()
-        if not logger.handlers:
-            logging.basicConfig()
-    format_msg = logger.handlers[0].formatter._fmt
-    fmt = ColorFormatter(format_msg, **kw)
-    fmt.colorfilters.append(xxx_cyan)
-    logger.handlers[0].setFormatter(fmt)
-
-
-LOG_FORMAT = '%(asctime)s - (%(name)s) %(levelname)s: %(message)s'
-LOG_DATE_FORMAT = '%Y-%m-%d %H:%M:%S'
-
-def init_log(debug=False, syslog=False, logthreshold=None, logfile=None,
-             logformat=LOG_FORMAT, logdateformat=LOG_DATE_FORMAT,
-             rotation_parameters=None):
-    """init the log service"""
-    if os.environ.get('APYCOT_ROOT'):
-        logthreshold = logging.CRITICAL
-        # redirect logs to stdout to avoid apycot output parsing failure
-        handler = logging.StreamHandler(sys.stdout)
-    else:
-        if debug:
-            handler = logging.StreamHandler()
-        elif logfile is None:
-            if syslog:
-                from logging import handlers
-                handler = handlers.SysLogHandler()
-            else:
-                handler = logging.StreamHandler()
-        else:
-            try:
-                if rotation_parameters is None:
-                    handler = logging.FileHandler(logfile)
-                else:
-                    from logging.handlers import TimedRotatingFileHandler
-                    handler = TimedRotatingFileHandler(logfile, 
-                                                       **rotation_parameters)
-            except IOError:
-                handler = logging.StreamHandler()
-        if logthreshold is None:
-            logthreshold = logging.ERROR
-        elif isinstance(logthreshold, basestring):
-            logthreshold = getattr(logging, THRESHOLD_MAP.get(logthreshold,
-                                                              logthreshold))
-    # configure the root logger
-    logger = logging.getLogger()
-    logger.setLevel(logthreshold)
-    # only addHandler and removeHandler method while I would like a
-    # setHandler method, so do it this way :$
-    logger.handlers = [handler]
-    isatty = hasattr(sys.__stdout__, 'isatty') and sys.__stdout__.isatty()
-    if debug and isatty and sys.platform != 'win32':
-        fmt = ColorFormatter(logformat, logdateformat)
-        def col_fact(record):
-            if 'XXX' in record.message:
-                return 'cyan'
-            if 'kick' in record.message:
-                return 'red'
-        fmt.colorfilters.append(col_fact)
-    else:
-        fmt = logging.Formatter(logformat, logdateformat)
-    handler.setFormatter(fmt)
-    return handler
-
-# map logilab.common.logger thresholds to logging thresholds
-THRESHOLD_MAP = {'LOG_DEBUG':   'DEBUG',
-                 'LOG_INFO':    'INFO',
-                 'LOG_NOTICE':  'INFO',
-                 'LOG_WARN':    'WARNING',
-                 'LOG_WARNING': 'WARNING',
-                 'LOG_ERR':     'ERROR',
-                 'LOG_ERROR':   'ERROR',
-                 'LOG_CRIT':    'CRITICAL',
-                 }