bee_python 0.0.1

data/tools/common/common/optik_ext.py

@@ -0,0 +1,383 @@
+# 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/>.
+"""Add an abstraction level to transparently import optik classes from optparse
+(python >= 2.3) or the optik package.
+
+It also defines three new types for optik/optparse command line parser :
+
+  * regexp
+    argument of this type will be converted using re.compile
+  * csv
+    argument of this type will be converted using split(',')
+  * yn
+    argument of this type will be true if 'y' or 'yes', false if 'n' or 'no'
+  * named
+    argument of this type are in the form <NAME>=<VALUE> or <NAME>:<VALUE>
+  * password
+    argument of this type wont be converted but this is used by other tools
+    such as interactive prompt for configuration to double check value and
+    use an invisible field
+  * multiple_choice
+    same as default "choice" type but multiple choices allowed
+  * file
+    argument of this type wont be converted but checked that the given file exists
+  * color
+    argument of this type wont be converted but checked its either a
+    named color or a color specified using hexadecimal notation (preceded by a #)
+  * time
+    argument of this type will be converted to a float value in seconds
+    according to time units (ms, s, min, h, d)
+  * bytes
+    argument of this type will be converted to a float value in bytes
+    according to byte units (b, kb, mb, gb, tb)
+"""
+__docformat__ = "restructuredtext en"
+
+import re
+import sys
+import time
+from copy import copy
+from os.path import exists
+
+# python >= 2.3
+from optparse import OptionParser as BaseParser, Option as BaseOption, \
+     OptionGroup, OptionContainer, OptionValueError, OptionError, \
+     Values, HelpFormatter, NO_DEFAULT, SUPPRESS_HELP
+
+try:
+    from mx import DateTime
+    HAS_MX_DATETIME = True
+except ImportError:
+    HAS_MX_DATETIME = False
+
+
+OPTPARSE_FORMAT_DEFAULT = sys.version_info >= (2, 4)
+
+from logilab.common.textutils import splitstrip
+
+def check_regexp(option, opt, value):
+    """check a regexp value by trying to compile it
+    return the compiled regexp
+    """
+    if hasattr(value, 'pattern'):
+        return value
+    try:
+        return re.compile(value)
+    except ValueError:
+        raise OptionValueError(
+            "option %s: invalid regexp value: %r" % (opt, value))
+
+def check_csv(option, opt, value):
+    """check a csv value by trying to split it
+    return the list of separated values
+    """
+    if isinstance(value, (list, tuple)):
+        return value
+    try:
+        return splitstrip(value)
+    except ValueError:
+        raise OptionValueError(
+            "option %s: invalid csv value: %r" % (opt, value))
+
+def check_yn(option, opt, value):
+    """check a yn value
+    return true for yes and false for no
+    """
+    if isinstance(value, int):
+        return bool(value)
+    if value in ('y', 'yes'):
+        return True
+    if value in ('n', 'no'):
+        return False
+    msg = "option %s: invalid yn value %r, should be in (y, yes, n, no)"
+    raise OptionValueError(msg % (opt, value))
+
+def check_named(option, opt, value):
+    """check a named value
+    return a dictionary containing (name, value) associations
+    """
+    if isinstance(value, dict):
+        return value
+    values = []
+    for value in check_csv(option, opt, value):
+        if value.find('=') != -1:
+            values.append(value.split('=', 1))
+        elif value.find(':') != -1:
+            values.append(value.split(':', 1))
+    if values:
+        return dict(values)
+    msg = "option %s: invalid named value %r, should be <NAME>=<VALUE> or \
+<NAME>:<VALUE>"
+    raise OptionValueError(msg % (opt, value))
+
+def check_password(option, opt, value):
+    """check a password value (can't be empty)
+    """
+    # no actual checking, monkey patch if you want more
+    return value
+
+def check_file(option, opt, value):
+    """check a file value
+    return the filepath
+    """
+    if exists(value):
+        return value
+    msg = "option %s: file %r does not exist"
+    raise OptionValueError(msg % (opt, value))
+
+# XXX use python datetime
+def check_date(option, opt, value):
+    """check a file value
+    return the filepath
+    """
+    try:
+        return DateTime.strptime(value, "%Y/%m/%d")
+    except DateTime.Error :
+        raise OptionValueError(
+            "expected format of %s is yyyy/mm/dd" % opt)
+
+def check_color(option, opt, value):
+    """check a color value and returns it
+    /!\ does *not* check color labels (like 'red', 'green'), only
+    checks hexadecimal forms
+    """
+    # Case (1) : color label, we trust the end-user
+    if re.match('[a-z0-9 ]+$', value, re.I):
+        return value
+    # Case (2) : only accepts hexadecimal forms
+    if re.match('#[a-f0-9]{6}', value, re.I):
+        return value
+    # Else : not a color label neither a valid hexadecimal form => error
+    msg = "option %s: invalid color : %r, should be either hexadecimal \
+    value or predefined color"
+    raise OptionValueError(msg % (opt, value))
+
+def check_time(option, opt, value):
+    from logilab.common.textutils import TIME_UNITS, apply_units
+    if isinstance(value, (int, long, float)):
+        return value
+    return apply_units(value, TIME_UNITS)
+
+def check_bytes(option, opt, value):
+    from logilab.common.textutils import BYTE_UNITS, apply_units
+    if hasattr(value, '__int__'):
+        return value
+    return apply_units(value, BYTE_UNITS)
+
+import types
+
+class Option(BaseOption):
+    """override optik.Option to add some new option types
+    """
+    TYPES = BaseOption.TYPES + ('regexp', 'csv', 'yn', 'named', 'password',
+                                'multiple_choice', 'file', 'color',
+                                'time', 'bytes')
+    ATTRS = BaseOption.ATTRS + ['hide', 'level']
+    TYPE_CHECKER = copy(BaseOption.TYPE_CHECKER)
+    TYPE_CHECKER['regexp'] = check_regexp
+    TYPE_CHECKER['csv'] = check_csv
+    TYPE_CHECKER['yn'] = check_yn
+    TYPE_CHECKER['named'] = check_named
+    TYPE_CHECKER['multiple_choice'] = check_csv
+    TYPE_CHECKER['file'] = check_file
+    TYPE_CHECKER['color'] = check_color
+    TYPE_CHECKER['password'] = check_password
+    TYPE_CHECKER['time'] = check_time
+    TYPE_CHECKER['bytes'] = check_bytes
+    if HAS_MX_DATETIME:
+        TYPES += ('date',)
+        TYPE_CHECKER['date'] = check_date
+
+    def __init__(self, *opts, **attrs):
+        BaseOption.__init__(self, *opts, **attrs)
+        if hasattr(self, "hide") and self.hide:
+            self.help = SUPPRESS_HELP
+
+    def _check_choice(self):
+        """FIXME: need to override this due to optik misdesign"""
+        if self.type in ("choice", "multiple_choice"):
+            if self.choices is None:
+                raise OptionError(
+                    "must supply a list of choices for type 'choice'", self)
+            elif type(self.choices) not in (types.TupleType, types.ListType):
+                raise OptionError(
+                    "choices must be a list of strings ('%s' supplied)"
+                    % str(type(self.choices)).split("'")[1], self)
+        elif self.choices is not None:
+            raise OptionError(
+                "must not supply choices for type %r" % self.type, self)
+    BaseOption.CHECK_METHODS[2] = _check_choice
+
+
+    def process(self, opt, value, values, parser):
+        # First, convert the value(s) to the right type.  Howl if any
+        # value(s) are bogus.
+        try:
+            value = self.convert_value(opt, value)
+        except AttributeError: # py < 2.4
+            value = self.check_value(opt, value)
+        if self.type == 'named':
+            existant = getattr(values, self.dest)
+            if existant:
+                existant.update(value)
+                value = existant
+       # And then take whatever action is expected of us.
+        # This is a separate method to make life easier for
+        # subclasses to add new actions.
+        return self.take_action(
+            self.action, self.dest, opt, value, values, parser)
+
+class OptionParser(BaseParser):
+    """override optik.OptionParser to use our Option class
+    """
+    def __init__(self, option_class=Option, *args, **kwargs):
+        BaseParser.__init__(self, option_class=Option, *args, **kwargs)
+
+    def format_option_help(self, formatter=None):
+        if formatter is None:
+            formatter = self.formatter
+        outputlevel = getattr(formatter, 'output_level', 0)
+        formatter.store_option_strings(self)
+        result = []
+        result.append(formatter.format_heading("Options"))
+        formatter.indent()
+        if self.option_list:
+            result.append(OptionContainer.format_option_help(self, formatter))
+            result.append("\n")
+        for group in self.option_groups:
+            if group.level <= outputlevel:
+                result.append(group.format_help(formatter))
+                result.append("\n")
+        formatter.dedent()
+        # Drop the last "\n", or the header if no options or option groups:
+        return "".join(result[:-1])
+
+
+OptionGroup.level = 0
+
+def format_option_help(self, formatter):
+    result = []
+    outputlevel = getattr(formatter, 'output_level', 0)
+    for option in self.option_list:
+        if getattr(option, 'level', 0) <= outputlevel and not option.help is SUPPRESS_HELP:
+            result.append(formatter.format_option(option))
+    return "".join(result)
+OptionContainer.format_option_help = format_option_help
+OptionContainer.format_option_help = format_option_help
+
+class ManHelpFormatter(HelpFormatter):
+    """Format help using man pages ROFF format"""
+
+    def __init__ (self,
+                  indent_increment=0,
+                  max_help_position=24,
+                  width=79,
+                  short_first=0):
+        HelpFormatter.__init__ (
+            self, indent_increment, max_help_position, width, short_first)
+
+    def format_heading(self, heading):
+        return '.SH %s\n' % heading.upper()
+
+    def format_description(self, description):
+        return description
+
+    def format_option(self, option):
+        try:
+            optstring = option.option_strings
+        except AttributeError:
+            optstring = self.format_option_strings(option)
+        if option.help:
+            help_text = self.expand_default(option)
+            help = ' '.join([l.strip() for l in help_text.splitlines()])
+        else:
+            help = ''
+        return '''.IP "%s"
+%s
+''' % (optstring, help)
+
+    def format_head(self, optparser, pkginfo, section=1):
+        try:
+            pgm = optparser._get_prog_name()
+        except AttributeError:
+            # py >= 2.4.X (dunno which X exactly, at least 2)
+            pgm = optparser.get_prog_name()
+        short_desc = self.format_short_description(pgm, pkginfo.description)
+        return '%s\n%s\n%s' % (self.format_title(pgm, section), short_desc,
+                               self.format_synopsis(pgm))
+
+    def format_title(self, pgm, section):
+        date = '-'.join([str(num) for num in time.localtime()[:3]])
+        return '.TH %s %s "%s" %s' % (pgm, section, date, pgm)
+
+    def format_short_description(self, pgm, short_desc):
+        return '''.SH NAME
+.B %s
+\- %s
+''' % (pgm, short_desc.strip())
+
+    def format_synopsis(self, pgm):
+        return '''.SH SYNOPSIS
+.B  %s
+[
+.I OPTIONS
+] [
+.I <arguments>
+]
+''' % pgm
+
+    def format_long_description(self, pgm, long_desc):
+        long_desc = '\n'.join([line.lstrip()
+                               for line in long_desc.splitlines()])
+        long_desc = long_desc.replace('\n.\n', '\n\n')
+        if long_desc.lower().startswith(pgm):
+            long_desc = long_desc[len(pgm):]
+        return '''.SH DESCRIPTION
+.B %s
+%s
+''' % (pgm, long_desc.strip())
+
+    def format_tail(self, pkginfo):
+        return '''.SH SEE ALSO
+/usr/share/doc/pythonX.Y-%s/
+
+.SH COPYRIGHT
+%s
+
+.SH BUGS
+Please report bugs on the project\'s mailing list:
+%s
+
+.SH AUTHOR
+%s <%s>
+''' % (getattr(pkginfo, 'debian_name', pkginfo.modname), pkginfo.copyright,
+       pkginfo.mailinglist, pkginfo.author, pkginfo.author_email)
+
+
+def generate_manpage(optparser, pkginfo, section=1, stream=sys.stdout, level=0):
+    """generate a man page from an optik parser"""
+    formatter = ManHelpFormatter()
+    formatter.output_level = level
+    formatter.parser = optparser
+    print >> stream, formatter.format_head(optparser, pkginfo, section)
+    print >> stream, optparser.format_option_help(formatter)
+    print >> stream, formatter.format_tail(pkginfo)
+
+
+__all__ = ('OptionParser', 'Option', 'OptionGroup', 'OptionValueError',
+           'Values')

data/tools/common/common/optparser.py

@@ -0,0 +1,92 @@
+# -*- 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/>.
+"""Extend OptionParser with commands.
+
+Example:
+
+>>> parser = OptionParser()
+>>> parser.usage = '%prog COMMAND [options] <arg> ...'
+>>> parser.add_command('build', 'mymod.build')
+>>> parser.add_command('clean', run_clean, add_opt_clean)
+>>> run, options, args = parser.parse_command(sys.argv[1:])
+>>> return run(options, args[1:])
+
+With mymod.build that defines two functions run and add_options
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+
+# XXX merge with optik_ext ? merge with clcommands ?
+
+import sys
+import optparse
+
+class OptionParser(optparse.OptionParser):
+
+    def __init__(self, *args, **kwargs):
+        optparse.OptionParser.__init__(self, *args, **kwargs)
+        self._commands = {}
+        self.min_args, self.max_args = 0, 1
+
+    def add_command(self, name, mod_or_funcs, help=''):
+        """name of the command
+	name of module or tuple of functions (run, add_options)
+	"""
+        assert isinstance(mod_or_funcs, str) or isinstance(mod_or_funcs, tuple), \
+	       "mod_or_funcs has to be a module name or a tuple of functions"
+        self._commands[name] = (mod_or_funcs, help)
+
+    def print_main_help(self):
+        optparse.OptionParser.print_help(self)
+        print '\ncommands:'
+        for cmdname, (_, help) in self._commands.items():
+            print '% 10s - %s' % (cmdname, help)
+
+    def parse_command(self, args):
+        if len(args) == 0:
+            self.print_main_help()
+            sys.exit(1)
+        cmd = args[0]
+	args = args[1:]
+        if cmd not in self._commands:
+            if cmd in ('-h', '--help'):
+                self.print_main_help()
+                sys.exit(0)
+            elif self.version is not None and cmd == "--version":
+                self.print_version()
+                sys.exit(0)
+            self.error('unknown command')
+        self.prog = '%s %s' % (self.prog, cmd)
+        mod_or_f, help = self._commands[cmd]
+        # optparse inserts self.description between usage and options help
+        self.description = help
+        if isinstance(mod_or_f, str):
+            exec 'from %s import run, add_options' % mod_or_f
+	else:
+	    run, add_options = mod_or_f
+        add_options(self)
+        (options, args) = self.parse_args(args)
+        if not (self.min_args <= len(args) <= self.max_args):
+            self.error('incorrect number of arguments')
+        return run, options, args
+
+

data/tools/common/common/pdf_ext.py

@@ -0,0 +1,111 @@
+# 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/>.
+"""Manipulate pdf and fdf files (pdftk recommended).
+
+Notes regarding pdftk, pdf forms and fdf files (form definition file)
+fields names can be extracted with:
+
+    pdftk orig.pdf generate_fdf output truc.fdf
+
+to merge fdf and pdf:
+
+    pdftk orig.pdf fill_form test.fdf output result.pdf [flatten]
+
+without flatten, one could further edit the resulting form.
+with flatten, everything is turned into text.
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+# XXX seems very unix specific
+# TODO: check availability of pdftk at import
+
+
+import os
+
+HEAD="""%FDF-1.2
+%\xE2\xE3\xCF\xD3
+1 0 obj
+<<
+/FDF
+<<
+/Fields [
+"""
+
+TAIL="""]
+>>
+>>
+endobj
+trailer
+
+<<
+/Root 1 0 R
+>>
+%%EOF
+"""
+
+def output_field( f ):
+    return "\xfe\xff" + "".join( [ "\x00"+c for c in f ] )
+
+def extract_keys(lines):
+    keys = []
+    for line in lines:
+        if line.startswith('/V'):
+            pass #print 'value',line
+        elif line.startswith('/T'):
+            key = line[7:-2]
+            key = ''.join(key.split('\x00'))
+            keys.append( key )
+    return keys
+
+def write_field(out, key, value):
+    out.write("<<\n")
+    if value:
+        out.write("/V (%s)\n" %value)
+    else:
+        out.write("/V /\n")
+    out.write("/T (%s)\n" % output_field(key) )
+    out.write(">> \n")
+
+def write_fields(out, fields):
+    out.write(HEAD)
+    for (key,value,comment) in fields:
+        write_field(out, key, value)
+        write_field(out, key+"a", value) # pour copie-carbone sur autres pages
+    out.write(TAIL)
+
+def extract_keys_from_pdf(filename):
+    # what about using 'pdftk filename dump_data_fields' and parsing the output ?
+    os.system('pdftk %s generate_fdf output /tmp/toto.fdf' % filename)
+    lines = file('/tmp/toto.fdf').readlines()
+    return extract_keys(lines)
+
+
+def fill_pdf(infile, outfile, fields):
+    write_fields(file('/tmp/toto.fdf', 'w'), fields)
+    os.system('pdftk %s fill_form /tmp/toto.fdf output %s flatten' % (infile, outfile))
+
+def testfill_pdf(infile, outfile):
+    keys = extract_keys_from_pdf(infile)
+    fields = []
+    for key in keys:
+        fields.append( (key, key, '') )
+    fill_pdf(infile, outfile, fields)
+