bee_python 0.0.3 → 0.0.4

data/tools/common/common/optik_ext.py

@@ -1,383 +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/>.
-"""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

@@ -1,92 +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/>.
-"""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

@@ -1,111 +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/>.
-"""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)
-