exercism-analysis 0.1.1

data/vendor/python/logilab/common/ureports/text_writer.py

@@ -0,0 +1,140 @@
+# copyright 2003-2011 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/>.
+"""Text formatting drivers for ureports"""
+__docformat__ = "restructuredtext en"
+
+from logilab.common.textutils import linesep
+from logilab.common.ureports import BaseWriter
+
+
+TITLE_UNDERLINES = ['', '=', '-', '`', '.', '~', '^']
+BULLETS = ['*', '-']
+
+class TextWriter(BaseWriter):
+    """format layouts as text
+    (ReStructured inspiration but not totally handled yet)
+    """
+    def begin_format(self, layout):
+        super(TextWriter, self).begin_format(layout)
+        self.list_level = 0
+        self.pending_urls = []
+
+    def visit_section(self, layout):
+        """display a section as text
+        """
+        self.section += 1
+        self.writeln()
+        self.format_children(layout)
+        if self.pending_urls:
+            self.writeln()
+            for label, url in self.pending_urls:
+                self.writeln('.. _`%s`: %s' % (label, url))
+            self.pending_urls = []
+        self.section -= 1
+        self.writeln()
+
+    def visit_title(self, layout):
+        title = ''.join(list(self.compute_content(layout)))
+        self.writeln(title)
+        try:
+            self.writeln(TITLE_UNDERLINES[self.section] * len(title))
+        except IndexError:
+            print "FIXME TITLE TOO DEEP. TURNING TITLE INTO TEXT"
+
+    def visit_paragraph(self, layout):
+        """enter a paragraph"""
+        self.format_children(layout)
+        self.writeln()
+
+    def visit_span(self, layout):
+        """enter a span"""
+        self.format_children(layout)
+
+    def visit_table(self, layout):
+        """display a table as text"""
+        table_content = self.get_table_content(layout)
+        # get columns width
+        cols_width = [0]*len(table_content[0])
+        for row in table_content:
+            for index in range(len(row)):
+                col = row[index]
+                cols_width[index] = max(cols_width[index], len(col))
+        if layout.klass == 'field':
+            self.field_table(layout, table_content, cols_width)
+        else:
+            self.default_table(layout, table_content, cols_width)
+        self.writeln()
+
+    def default_table(self, layout, table_content, cols_width):
+        """format a table"""
+        cols_width = [size+1 for size in cols_width]
+        format_strings = ' '.join(['%%-%ss'] * len(cols_width))
+        format_strings = format_strings % tuple(cols_width)
+        format_strings = format_strings.split(' ')
+        table_linesep = '\n+' + '+'.join(['-'*w for w in cols_width]) + '+\n'
+        headsep = '\n+' + '+'.join(['='*w for w in cols_width]) + '+\n'
+        # FIXME: layout.cheaders
+        self.write(table_linesep)
+        for i in range(len(table_content)):
+            self.write('|')
+            line = table_content[i]
+            for j in range(len(line)):
+                self.write(format_strings[j] % line[j])
+                self.write('|')
+            if i == 0 and layout.rheaders:
+                self.write(headsep)
+            else:
+                self.write(table_linesep)
+
+    def field_table(self, layout, table_content, cols_width):
+        """special case for field table"""
+        assert layout.cols == 2
+        format_string = '%s%%-%ss: %%s' % (linesep, cols_width[0])
+        for field, value in table_content:
+            self.write(format_string % (field, value))
+
+
+    def visit_list(self, layout):
+        """display a list layout as text"""
+        bullet = BULLETS[self.list_level % len(BULLETS)]
+        indent = '  ' * self.list_level
+        self.list_level += 1
+        for child in layout.children:
+            self.write('%s%s%s ' % (linesep, indent, bullet))
+            child.accept(self)
+        self.list_level -= 1
+
+    def visit_link(self, layout):
+        """add a hyperlink"""
+        if layout.label != layout.url:
+            self.write('`%s`_' % layout.label)
+            self.pending_urls.append( (layout.label, layout.url) )
+        else:
+            self.write(layout.url)
+
+    def visit_verbatimtext(self, layout):
+        """display a verbatim layout as text (so difficult ;)
+        """
+        self.writeln('::\n')
+        for line in layout.data.splitlines():
+            self.writeln('    ' + line)
+        self.writeln()
+
+    def visit_text(self, layout):
+        """add some text"""
+        self.write(layout.data)

data/vendor/python/logilab/common/urllib2ext.py

@@ -0,0 +1,87 @@
+import logging
+import urllib2
+
+import kerberos as krb
+
+class GssapiAuthError(Exception):
+    """raised on error during authentication process"""
+
+import re
+RGX = re.compile('(?:.*,)*\s*Negotiate\s*([^,]*),?', re.I)
+
+def get_negociate_value(headers):
+    for authreq in headers.getheaders('www-authenticate'):
+        match = RGX.search(authreq)
+        if match:
+            return match.group(1)
+
+class HTTPGssapiAuthHandler(urllib2.BaseHandler):
+    """Negotiate HTTP authentication using context from GSSAPI"""
+
+    handler_order = 400 # before Digest Auth
+
+    def __init__(self):
+        self._reset()
+
+    def _reset(self):
+        self._retried = 0
+        self._context = None
+
+    def clean_context(self):
+        if self._context is not None:
+            krb.authGSSClientClean(self._context)
+
+    def http_error_401(self, req, fp, code, msg, headers):
+        try:
+            if self._retried > 5:
+                raise urllib2.HTTPError(req.get_full_url(), 401,
+                                        "negotiate auth failed", headers, None)
+            self._retried += 1
+            logging.debug('gssapi handler, try %s' % self._retried)
+            negotiate = get_negociate_value(headers)
+            if negotiate is None:
+                logging.debug('no negociate found in a www-authenticate header')
+                return None
+            logging.debug('HTTPGssapiAuthHandler: negotiate 1 is %r' % negotiate)
+            result, self._context = krb.authGSSClientInit("HTTP@%s" % req.get_host())
+            if result < 1:
+                raise GssapiAuthError("HTTPGssapiAuthHandler: init failed with %d" % result)
+            result = krb.authGSSClientStep(self._context, negotiate)
+            if result < 0:
+                raise GssapiAuthError("HTTPGssapiAuthHandler: step 1 failed with %d" % result)
+            client_response = krb.authGSSClientResponse(self._context)
+            logging.debug('HTTPGssapiAuthHandler: client response is %s...' % client_response[:10])
+            req.add_unredirected_header('Authorization', "Negotiate %s" % client_response)
+            server_response = self.parent.open(req)
+            negotiate = get_negociate_value(server_response.info())
+            if negotiate is None:
+                logging.warning('HTTPGssapiAuthHandler: failed to authenticate server')
+            else:
+                logging.debug('HTTPGssapiAuthHandler negotiate 2: %s' % negotiate)
+                result = krb.authGSSClientStep(self._context, negotiate)
+                if result < 1:
+                    raise GssapiAuthError("HTTPGssapiAuthHandler: step 2 failed with %d" % result)
+            return server_response
+        except GssapiAuthError, exc:
+            logging.error(repr(exc))
+        finally:
+            self.clean_context()
+            self._reset()
+
+if __name__ == '__main__':
+    import sys
+    # debug
+    import httplib
+    httplib.HTTPConnection.debuglevel = 1
+    httplib.HTTPSConnection.debuglevel = 1
+    # debug
+    import logging
+    logging.basicConfig(level=logging.DEBUG)
+    # handle cookies
+    import cookielib
+    cj = cookielib.CookieJar()
+    ch = urllib2.HTTPCookieProcessor(cj)
+    # test with url sys.argv[1]
+    h = HTTPGssapiAuthHandler()
+    response = urllib2.build_opener(h, ch).open(sys.argv[1])
+    print '\nresponse: %s\n--------------\n' % response.code, response.info()

data/vendor/python/logilab/common/vcgutils.py

@@ -0,0 +1,216 @@
+# copyright 2003-2011 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/>.
+"""Functions to generate files readable with Georg Sander's vcg
+(Visualization of Compiler Graphs).
+
+You can download vcg at http://rw4.cs.uni-sb.de/~sander/html/gshome.html
+Note that vcg exists as a debian package.
+
+See vcg's documentation for explanation about the different values that
+maybe used for the functions parameters.
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+
+import string
+
+ATTRS_VAL = {
+    'algos':       ('dfs', 'tree', 'minbackward',
+                    'left_to_right', 'right_to_left',
+                    'top_to_bottom', 'bottom_to_top',
+                    'maxdepth', 'maxdepthslow', 'mindepth', 'mindepthslow',
+                    'mindegree', 'minindegree', 'minoutdegree',
+                    'maxdegree', 'maxindegree', 'maxoutdegree'),
+    'booleans':    ('yes', 'no'),
+    'colors':      ('black', 'white', 'blue', 'red', 'green', 'yellow',
+                    'magenta', 'lightgrey',
+                    'cyan', 'darkgrey', 'darkblue', 'darkred', 'darkgreen',
+                    'darkyellow', 'darkmagenta', 'darkcyan', 'gold',
+                    'lightblue', 'lightred', 'lightgreen', 'lightyellow',
+                    'lightmagenta', 'lightcyan', 'lilac', 'turquoise',
+                    'aquamarine', 'khaki', 'purple', 'yellowgreen', 'pink',
+                    'orange', 'orchid'),
+    'shapes':      ('box', 'ellipse', 'rhomb', 'triangle'),
+    'textmodes':   ('center', 'left_justify', 'right_justify'),
+    'arrowstyles': ('solid', 'line', 'none'),
+    'linestyles':  ('continuous', 'dashed', 'dotted', 'invisible'),
+    }
+
+# meaning of possible values:
+#   O    -> string
+#   1    -> int
+#   list -> value in list
+GRAPH_ATTRS = {
+    'title':              0,
+    'label':              0,
+    'color':               ATTRS_VAL['colors'],
+    'textcolor':           ATTRS_VAL['colors'],
+    'bordercolor':         ATTRS_VAL['colors'],
+    'width':               1,
+    'height':              1,
+    'borderwidth':         1,
+    'textmode':            ATTRS_VAL['textmodes'],
+    'shape':               ATTRS_VAL['shapes'],
+    'shrink':              1,
+    'stretch':             1,
+    'orientation':         ATTRS_VAL['algos'],
+    'vertical_order':      1,
+    'horizontal_order':    1,
+    'xspace':              1,
+    'yspace':              1,
+    'layoutalgorithm':    ATTRS_VAL['algos'],
+    'late_edge_labels':   ATTRS_VAL['booleans'],
+    'display_edge_labels': ATTRS_VAL['booleans'],
+    'dirty_edge_labels':  ATTRS_VAL['booleans'],
+    'finetuning':          ATTRS_VAL['booleans'],
+    'manhattan_edges':     ATTRS_VAL['booleans'],
+    'smanhattan_edges':    ATTRS_VAL['booleans'],
+    'port_sharing':        ATTRS_VAL['booleans'],
+    'edges':               ATTRS_VAL['booleans'],
+    'nodes':               ATTRS_VAL['booleans'],
+    'splines':             ATTRS_VAL['booleans'],
+    }
+NODE_ATTRS = {
+    'title':              0,
+    'label':              0,
+    'color':               ATTRS_VAL['colors'],
+    'textcolor':           ATTRS_VAL['colors'],
+    'bordercolor':         ATTRS_VAL['colors'],
+    'width':               1,
+    'height':              1,
+    'borderwidth':         1,
+    'textmode':            ATTRS_VAL['textmodes'],
+    'shape':               ATTRS_VAL['shapes'],
+    'shrink':              1,
+    'stretch':             1,
+    'vertical_order':      1,
+    'horizontal_order':    1,
+    }
+EDGE_ATTRS = {
+    'sourcename':         0,
+    'targetname':         0,
+    'label':              0,
+    'linestyle':          ATTRS_VAL['linestyles'],
+    'class':              1,
+    'thickness':          0,
+    'color':               ATTRS_VAL['colors'],
+    'textcolor':           ATTRS_VAL['colors'],
+    'arrowcolor':          ATTRS_VAL['colors'],
+    'backarrowcolor':      ATTRS_VAL['colors'],
+    'arrowsize':           1,
+    'backarrowsize':       1,
+    'arrowstyle':          ATTRS_VAL['arrowstyles'],
+    'backarrowstyle':      ATTRS_VAL['arrowstyles'],
+    'textmode':            ATTRS_VAL['textmodes'],
+    'priority':            1,
+    'anchor':              1,
+    'horizontal_order':    1,
+    }
+
+
+# Misc utilities ###############################################################
+
+def latin_to_vcg(st):
+    """Convert latin characters using vcg escape sequence.
+    """
+    for char in st:
+        if char not in string.ascii_letters:
+            try:
+                num = ord(char)
+                if num >= 192:
+                    st = st.replace(char, r'\fi%d'%ord(char))
+            except:
+                pass
+    return st
+
+
+class VCGPrinter:
+    """A vcg graph writer.
+    """
+
+    def __init__(self, output_stream):
+        self._stream = output_stream
+        self._indent = ''
+
+    def open_graph(self, **args):
+        """open a vcg graph
+        """
+        self._stream.write('%sgraph:{\n'%self._indent)
+        self._inc_indent()
+        self._write_attributes(GRAPH_ATTRS, **args)
+
+    def close_graph(self):
+        """close a vcg graph
+        """
+        self._dec_indent()
+        self._stream.write('%s}\n'%self._indent)
+
+
+    def node(self, title, **args):
+        """draw a node
+        """
+        self._stream.write('%snode: {title:"%s"' % (self._indent, title))
+        self._write_attributes(NODE_ATTRS, **args)
+        self._stream.write('}\n')
+
+
+    def edge(self, from_node, to_node, edge_type='', **args):
+        """draw an edge from a node to another.
+        """
+        self._stream.write(
+            '%s%sedge: {sourcename:"%s" targetname:"%s"' % (
+            self._indent, edge_type, from_node, to_node))
+        self._write_attributes(EDGE_ATTRS, **args)
+        self._stream.write('}\n')
+
+
+    # private ##################################################################
+
+    def _write_attributes(self, attributes_dict, **args):
+        """write graph, node or edge attributes
+        """
+        for key, value in args.items():
+            try:
+                _type =  attributes_dict[key]
+            except KeyError:
+                raise Exception('''no such attribute %s
+possible attributes are %s''' % (key, attributes_dict.keys()))
+
+            if not _type:
+                self._stream.write('%s%s:"%s"\n' % (self._indent, key, value))
+            elif _type == 1:
+                self._stream.write('%s%s:%s\n' % (self._indent, key,
+                                                  int(value)))
+            elif value in _type:
+                self._stream.write('%s%s:%s\n' % (self._indent, key, value))
+            else:
+                raise Exception('''value %s isn\'t correct for attribute %s
+correct values are %s''' % (value, key, _type))
+
+    def _inc_indent(self):
+        """increment indentation
+        """
+        self._indent = '  %s' % self._indent
+
+    def _dec_indent(self):
+        """decrement indentation
+        """
+        self._indent = self._indent[:-2]

data/vendor/python/logilab/common/visitor.py

@@ -0,0 +1,107 @@
+# copyright 2003-2011 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/>.
+"""A generic visitor abstract implementation.
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+
+def no_filter(_):
+    return 1
+
+# Iterators ###################################################################
+class FilteredIterator(object):
+
+    def __init__(self, node, list_func, filter_func=None):
+        self._next = [(node, 0)]
+        if filter_func is None:
+            filter_func = no_filter
+        self._list = list_func(node, filter_func)
+
+    def next(self):
+        try:
+            return self._list.pop(0)
+        except :
+            return None
+
+# Base Visitor ################################################################
+class Visitor(object):
+
+    def __init__(self, iterator_class, filter_func=None):
+        self._iter_class = iterator_class
+        self.filter = filter_func
+
+    def visit(self, node, *args, **kargs):
+        """
+        launch the visit on a given node
+
+        call 'open_visit' before the beginning of the visit, with extra args
+        given
+        when all nodes have been visited, call the 'close_visit' method
+        """
+        self.open_visit(node, *args, **kargs)
+        return self.close_visit(self._visit(node))
+
+    def _visit(self, node):
+        iterator = self._get_iterator(node)
+        n = iterator.next()
+        while n:
+            result = n.accept(self)
+            n = iterator.next()
+        return result
+
+    def _get_iterator(self, node):
+        return self._iter_class(node, self.filter)
+
+    def open_visit(self, *args, **kargs):
+        """
+        method called at the beginning of the visit
+        """
+        pass
+
+    def close_visit(self, result):
+        """
+        method called at the end of the visit
+        """
+        return result
+
+# standard visited mixin ######################################################
+class VisitedMixIn(object):
+    """
+    Visited interface allow node visitors to use the node
+    """
+    def get_visit_name(self):
+        """
+        return the visit name for the mixed class. When calling 'accept', the
+        method <'visit_' + name returned by this method> will be called on the
+        visitor
+        """
+        try:
+            return self.TYPE.replace('-', '_')
+        except:
+            return self.__class__.__name__.lower()
+
+    def accept(self, visitor, *args, **kwargs):
+        func = getattr(visitor, 'visit_%s' % self.get_visit_name())
+        return func(self, *args, **kwargs)
+
+    def leave(self, visitor, *args, **kwargs):
+        func = getattr(visitor, 'leave_%s' % self.get_visit_name())
+        return func(self, *args, **kwargs)