bee_python 0.0.1

data/tools/common/common/contexts.py

@@ -0,0 +1,58 @@
+# 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/>.
+"""A few useful context managers
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+
+import sys
+
+if sys.version_info < (2, 5):
+    raise ImportError("python >= 2.5 is required to import logilab.common.contexts")
+
+import os
+import tempfile
+import shutil
+
+class tempdir(object):
+
+    def __enter__(self):
+        self.path = tempfile.mkdtemp()
+        return self.path
+
+    def __exit__(self, exctype, value, traceback):
+        # rmtree in all cases
+        shutil.rmtree(self.path)
+        return traceback is None
+
+
+class pushd(object):
+    def __init__(self, directory):
+        self.directory = directory
+
+    def __enter__(self):
+        self.cwd = os.getcwd()
+        os.chdir(self.directory)
+        return self.directory
+
+    def __exit__(self, exctype, value, traceback):
+        os.chdir(self.cwd)
+

data/tools/common/common/corbautils.py

@@ -0,0 +1,117 @@
+# 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/>.
+"""A set of utility function to ease the use of OmniORBpy.
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+
+from omniORB import CORBA, PortableServer
+import CosNaming
+
+orb = None
+
+def get_orb():
+    """
+    returns a reference to the ORB.
+    The first call to the method initialized the ORB
+    This method is mainly used internally in the module.
+    """
+
+    global orb
+    if orb is None:
+        import sys
+        orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
+    return orb
+
+def get_root_context():
+    """
+    returns a reference to the NameService object.
+    This method is mainly used internally in the module.
+    """
+
+    orb = get_orb()
+    nss = orb.resolve_initial_references("NameService")
+    rootContext = nss._narrow(CosNaming.NamingContext)
+    assert rootContext is not None,"Failed to narrow root naming context"
+    return rootContext
+
+def register_object_name(object, namepath):
+    """
+    Registers a object in the NamingService.
+    The name path is a list of 2-uples (id,kind) giving the path.
+
+    For instance if the path of an object is [('foo',''),('bar','')],
+    it is possible to get a reference to the object using the URL
+    'corbaname::hostname#foo/bar'.
+    [('logilab','rootmodule'),('chatbot','application'),('chatter','server')]
+    is mapped to
+    'corbaname::hostname#logilab.rootmodule/chatbot.application/chatter.server'
+
+    The get_object_reference() function can be used to resolve such a URL.
+    """
+    context = get_root_context()
+    for id, kind in namepath[:-1]:
+        name = [CosNaming.NameComponent(id, kind)]
+        try:
+            context = context.bind_new_context(name)
+        except CosNaming.NamingContext.AlreadyBound, ex:
+            context = context.resolve(name)._narrow(CosNaming.NamingContext)
+            assert context is not None, \
+                   'test context exists but is not a NamingContext'
+
+    id,kind = namepath[-1]
+    name = [CosNaming.NameComponent(id, kind)]
+    try:
+        context.bind(name, object._this())
+    except CosNaming.NamingContext.AlreadyBound, ex:
+        context.rebind(name, object._this())
+
+def activate_POA():
+    """
+    This methods activates the Portable Object Adapter.
+    You need to call it to enable the reception of messages in your code,
+    on both the client and the server.
+    """
+    orb = get_orb()
+    poa = orb.resolve_initial_references('RootPOA')
+    poaManager = poa._get_the_POAManager()
+    poaManager.activate()
+
+def run_orb():
+    """
+    Enters the ORB mainloop on the server.
+    You should not call this method on the client.
+    """
+    get_orb().run()
+
+def get_object_reference(url):
+    """
+    Resolves a corbaname URL to an object proxy.
+    See register_object_name() for examples URLs
+    """
+    return get_orb().string_to_object(url)
+
+def get_object_string(host, namepath):
+    """given an host name and a name path as described in register_object_name,
+    return a corba string identifier
+    """
+    strname = '/'.join(['.'.join(path_elt) for path_elt in namepath])
+    return 'corbaname::%s#%s' % (host, strname)

data/tools/common/common/daemon.py

@@ -0,0 +1,171 @@
+# 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/>.
+"""A daemonize function (for Unices) and daemon mix-in class"""
+
+__docformat__ = "restructuredtext en"
+
+import os
+import errno
+import signal
+import sys
+import time
+import warnings
+
+
+def daemonize(pidfile):
+    # See http://www.erlenstar.demon.co.uk/unix/faq_toc.html#TOC16
+    # XXX unix specific
+    #
+    # fork so the parent can exit
+    if os.fork():   # launch child and...
+        return 1
+    # deconnect from tty and create a new session
+    os.setsid()
+    # fork again so the parent, (the session group leader), can exit.
+    # as a non-session group leader, we can never regain a controlling
+    # terminal.
+    if os.fork():   # launch child again.
+        return 1
+    # move to the root to avoit mount pb
+    os.chdir('/')
+    # set paranoid umask
+    os.umask(077)
+    # redirect standard descriptors
+    null = os.open('/dev/null', os.O_RDWR)
+    for i in range(3):
+        try:
+            os.dup2(null, i)
+        except OSError, e:
+            if e.errno != errno.EBADF:
+                raise
+    os.close(null)
+    # filter warnings
+    warnings.filterwarnings('ignore')
+    # write pid in a file
+    if pidfile:
+        # ensure the directory where the pid-file should be set exists (for
+        # instance /var/run/cubicweb may be deleted on computer restart)
+        piddir = os.path.dirname(pidfile)
+        if not os.path.exists(piddir):
+            os.makedirs(piddir)
+        f = file(pidfile, 'w')
+        f.write(str(os.getpid()))
+        f.close()
+    return None
+
+
+class DaemonMixIn:
+    """Mixin to make a daemon from watchers/queriers.
+    """
+
+    def __init__(self, configmod) :
+        self.delay = configmod.DELAY
+        self.name = str(self.__class__).split('.')[-1]
+        self._pid_file = os.path.join('/tmp', '%s.pid'%self.name)
+        if os.path.exists(self._pid_file):
+            raise Exception('''Another instance of %s must be running.
+If it i not the case, remove the file %s''' % (self.name, self._pid_file))
+        self._alive = 1
+        self._sleeping = 0
+        self.config = configmod
+
+    def _daemonize(self):
+        if not self.config.NODETACH:
+            if daemonize(self._pid_file) is None:
+                # put signal handler
+                signal.signal(signal.SIGTERM, self.signal_handler)
+                signal.signal(signal.SIGHUP, self.signal_handler)
+            else:
+                return -1
+
+    def run(self):
+        """ optionally go in daemon mode and
+        do what concrete class has to do and pauses for delay between runs
+        If self.delay is negative, do a pause before starting
+        """
+        if self._daemonize() == -1:
+            return
+        if self.delay < 0:
+            self.delay = -self.delay
+            time.sleep(self.delay)
+        while 1:
+            try:
+                self._run()
+            except Exception, ex:
+                # display for info, sleep, and hope the problem will be solved
+                # later.
+                self.config.exception('Internal error: %s', ex)
+            if not self._alive:
+                break
+            try:
+                self._sleeping = 1
+                time.sleep(self.delay)
+                self._sleeping = 0
+            except SystemExit:
+                break
+        self.config.info('%s instance exited', self.name)
+        # remove pid file
+        os.remove(self._pid_file)
+
+    def signal_handler(self, sig_num, stack_frame):
+        if sig_num == signal.SIGTERM:
+            if self._sleeping:
+                # we are sleeping so we can exit without fear
+                self.config.debug('exit on SIGTERM')
+                sys.exit(0)
+            else:
+                self.config.debug('exit on SIGTERM (on next turn)')
+                self._alive = 0
+        elif sig_num == signal.SIGHUP:
+            self.config.info('reloading configuration on SIGHUP')
+            reload(self.config)
+
+    def _run(self):
+        """should be overridden in the mixed class"""
+        raise NotImplementedError()
+
+
+import logging
+from logilab.common.logging_ext import set_log_methods
+set_log_methods(DaemonMixIn, logging.getLogger('lgc.daemon'))
+
+## command line utilities ######################################################
+
+L_OPTIONS = ["help", "log=", "delay=", 'no-detach']
+S_OPTIONS = 'hl:d:n'
+
+def print_help(modconfig):
+    print """  --help or -h
+    displays this message
+  --log <log_level>
+    log treshold (7 record everything, 0 record only emergency.)
+    Defaults to %s
+  --delay <delay>
+    the number of seconds between two runs.
+    Defaults to %s""" % (modconfig.LOG_TRESHOLD, modconfig.DELAY)
+
+def handle_option(modconfig, opt_name, opt_value, help_meth):
+    if opt_name in ('-h','--help'):
+        help_meth()
+        sys.exit(0)
+    elif opt_name in ('-l','--log'):
+        modconfig.LOG_TRESHOLD = int(opt_value)
+    elif opt_name in ('-d', '--delay'):
+        modconfig.DELAY = int(opt_value)
+    elif opt_name in ('-n', '--no-detach'):
+        modconfig.NODETACH = 1

data/tools/common/common/date.py

@@ -0,0 +1,279 @@
+# 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/>.
+"""Date manipulation helper functions.
+
+
+
+
+"""
+__docformat__ = "restructuredtext en"
+
+import math
+from locale import getpreferredencoding
+from datetime import date, time, datetime, timedelta
+from time import strptime as time_strptime
+from calendar import monthrange, timegm
+
+try:
+    from mx.DateTime import RelativeDateTime, Date, DateTimeType
+except ImportError:
+    from warnings import warn
+    warn("mxDateTime not found, endOfMonth won't be available")
+    endOfMonth = None
+    DateTimeType = datetime
+else:
+    endOfMonth = RelativeDateTime(months=1, day=-1)
+
+# NOTE: should we implement a compatibility layer between date representations
+#       as we have in lgc.db ?
+
+FRENCH_FIXED_HOLIDAYS = {
+    'jour_an'        : '%s-01-01',
+    'fete_travail'   : '%s-05-01',
+    'armistice1945'  : '%s-05-08',
+    'fete_nat'       : '%s-07-14',
+    'assomption'     : '%s-08-15',
+    'toussaint'      : '%s-11-01',
+    'armistice1918'  : '%s-11-11',
+    'noel'           : '%s-12-25',
+    }
+
+FRENCH_MOBILE_HOLIDAYS = {
+    'paques2004'    : '2004-04-12',
+    'ascension2004' : '2004-05-20',
+    'pentecote2004' : '2004-05-31',
+
+    'paques2005'    : '2005-03-28',
+    'ascension2005' : '2005-05-05',
+    'pentecote2005' : '2005-05-16',
+
+    'paques2006'    : '2006-04-17',
+    'ascension2006' : '2006-05-25',
+    'pentecote2006' : '2006-06-05',
+
+    'paques2007'    : '2007-04-09',
+    'ascension2007' : '2007-05-17',
+    'pentecote2007' : '2007-05-28',
+
+    'paques2008'    : '2008-03-24',
+    'ascension2008' : '2008-05-01',
+    'pentecote2008' : '2008-05-12',
+
+    'paques2009'    : '2009-04-13',
+    'ascension2009' : '2009-05-21',
+    'pentecote2009' : '2009-06-01',
+
+    'paques2010'    : '2010-04-05',
+    'ascension2010' : '2010-05-13',
+    'pentecote2010' : '2010-05-24',
+
+    'paques2011'    : '2011-04-25',
+    'ascension2011' : '2011-06-02',
+    'pentecote2011' : '2011-06-13',
+
+    'paques2012'    : '2012-04-09',
+    'ascension2012' : '2012-05-17',
+    'pentecote2012' : '2012-05-28',
+    }
+
+# XXX this implementation cries for multimethod dispatching
+
+def get_step(dateobj, nbdays=1):
+    # assume date is either a python datetime or a mx.DateTime object
+    if isinstance(dateobj, date):
+        return ONEDAY * nbdays
+    return nbdays # mx.DateTime is ok with integers
+
+def datefactory(year, month, day, sampledate):
+    # assume date is either a python datetime or a mx.DateTime object
+    if isinstance(sampledate, datetime):
+        return datetime(year, month, day)
+    if isinstance(sampledate, date):
+        return date(year, month, day)
+    return Date(year, month, day)
+
+def weekday(dateobj):
+    # assume date is either a python datetime or a mx.DateTime object
+    if isinstance(dateobj, date):
+        return dateobj.weekday()
+    return dateobj.day_of_week
+
+def str2date(datestr, sampledate):
+    # NOTE: datetime.strptime is not an option until we drop py2.4 compat
+    year, month, day = [int(chunk) for chunk in datestr.split('-')]
+    return datefactory(year, month, day, sampledate)
+
+def days_between(start, end):
+    if isinstance(start, date):
+        delta = end - start
+        # datetime.timedelta.days is always an integer (floored)
+        if delta.seconds:
+            return delta.days + 1
+        return delta.days
+    else:
+        return int(math.ceil((end - start).days))
+
+def get_national_holidays(begin, end):
+    """return french national days off between begin and end"""
+    begin = datefactory(begin.year, begin.month, begin.day, begin)
+    end = datefactory(end.year, end.month, end.day, end)
+    holidays = [str2date(datestr, begin)
+                for datestr in FRENCH_MOBILE_HOLIDAYS.values()]
+    for year in xrange(begin.year, end.year+1):
+        for datestr in FRENCH_FIXED_HOLIDAYS.values():
+            date = str2date(datestr % year, begin)
+            if date not in holidays:
+                holidays.append(date)
+    return [day for day in holidays if begin <= day < end]
+
+def add_days_worked(start, days):
+    """adds date but try to only take days worked into account"""
+    step = get_step(start)
+    weeks, plus = divmod(days, 5)
+    end = start + ((weeks * 7) + plus) * step
+    if weekday(end) >= 5: # saturday or sunday
+        end += (2 * step)
+    end += len([x for x in get_national_holidays(start, end + step)
+                if weekday(x) < 5]) * step
+    if weekday(end) >= 5: # saturday or sunday
+        end += (2 * step)
+    return end
+
+def nb_open_days(start, end):
+    assert start <= end
+    step = get_step(start)
+    days = days_between(start, end)
+    weeks, plus = divmod(days, 7)
+    if weekday(start) > weekday(end):
+        plus -= 2
+    elif weekday(end) == 6:
+        plus -= 1
+    open_days = weeks * 5 + plus
+    nb_week_holidays = len([x for x in get_national_holidays(start, end+step)
+                            if weekday(x) < 5 and x < end])
+    open_days -= nb_week_holidays
+    if open_days < 0:
+        return 0
+    return open_days
+
+def date_range(begin, end, incday=None, incmonth=None):
+    """yields each date between begin and end
+
+    :param begin: the start date
+    :param end: the end date
+    :param incr: the step to use to iterate over dates. Default is
+                 one day.
+    :param include: None (means no exclusion) or a function taking a
+                    date as parameter, and returning True if the date
+                    should be included.
+
+    When using mx datetime, you should *NOT* use incmonth argument, use instead
+    oneDay, oneHour, oneMinute, oneSecond, oneWeek or endOfMonth (to enumerate
+    months) as `incday` argument
+    """
+    assert not (incday and incmonth)
+    begin = todate(begin)
+    end = todate(end)
+    if incmonth:
+        while begin < end:
+            begin = next_month(begin, incmonth)
+            yield begin
+    else:
+        incr = get_step(begin, incday or 1)
+        while begin < end:
+           yield begin
+           begin += incr
+
+# makes py datetime usable #####################################################
+
+ONEDAY = timedelta(days=1)
+ONEWEEK = timedelta(days=7)
+
+try:
+    strptime = datetime.strptime
+except AttributeError: # py < 2.5
+    from time import strptime as time_strptime
+    def strptime(value, format):
+        return datetime(*time_strptime(value, format)[:6])
+
+def strptime_time(value, format='%H:%M'):
+    return time(*time_strptime(value, format)[3:6])
+
+def todate(somedate):
+    """return a date from a date (leaving unchanged) or a datetime"""
+    if isinstance(somedate, datetime):
+        return date(somedate.year, somedate.month, somedate.day)
+    assert isinstance(somedate, (date, DateTimeType)), repr(somedate)
+    return somedate
+
+def totime(somedate):
+    """return a time from a time (leaving unchanged), date or datetime"""
+    # XXX mx compat
+    if not isinstance(somedate, time):
+        return time(somedate.hour, somedate.minute, somedate.second)
+    assert isinstance(somedate, (time)), repr(somedate)
+    return somedate
+
+def todatetime(somedate):
+    """return a date from a date (leaving unchanged) or a datetime"""
+    # take care, datetime is a subclass of date
+    if isinstance(somedate, datetime):
+        return somedate
+    assert isinstance(somedate, (date, DateTimeType)), repr(somedate)
+    return datetime(somedate.year, somedate.month, somedate.day)
+
+def datetime2ticks(somedate):
+    return timegm(somedate.timetuple()) * 1000
+
+def days_in_month(somedate):
+    return monthrange(somedate.year, somedate.month)[1]
+
+def days_in_year(somedate):
+    feb = date(somedate.year, 2, 1)
+    if days_in_month(feb) == 29:
+        return 366
+    else:
+        return 365
+
+def previous_month(somedate, nbmonth=1):
+    while nbmonth:
+        somedate = first_day(somedate) - ONEDAY
+        nbmonth -= 1
+    return somedate
+
+def next_month(somedate, nbmonth=1):
+    while nbmonth:
+        somedate = last_day(somedate) + ONEDAY
+        nbmonth -= 1
+    return somedate
+
+def first_day(somedate):
+    return date(somedate.year, somedate.month, 1)
+
+def last_day(somedate):
+    return date(somedate.year, somedate.month, days_in_month(somedate))
+
+def ustrftime(somedate, fmt='%Y-%m-%d'):
+    """like strftime, but returns a unicode string instead of an encoded
+    string which' may be problematic with localized date.
+
+    encoding is guessed by locale.getpreferredencoding()
+    """
+    # date format may depend on the locale
+    encoding = getpreferredencoding(do_setlocale=False) or 'UTF-8'
+    return unicode(somedate.strftime(str(fmt)), encoding)

data/tools/common/common/db.py

@@ -0,0 +1,49 @@
+# 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/>.
+"""Wrappers to get actually replaceable DBAPI2 compliant modules and
+database connection whatever the database and client lib used.
+
+Currently support:
+
+- postgresql (pgdb, psycopg, psycopg2, pyPgSQL)
+- mysql (MySQLdb)
+- sqlite (pysqlite2, sqlite, sqlite3)
+
+just use the `get_connection` function from this module to get a
+wrapped connection.  If multiple drivers for a database are available,
+you can control which one you want to use using the
+`set_prefered_driver` function.
+
+Additional helpers are also provided for advanced functionalities such
+as listing existing users or databases, creating database... Get the
+helper for your database using the `get_adv_func_helper` function.
+"""
+__docformat__ = "restructuredtext en"
+
+from warnings import warn
+warn('this module is deprecated, use logilab.database instead',
+     DeprecationWarning, stacklevel=1)
+
+from logilab.database import (get_connection, set_prefered_driver,
+                        get_dbapi_compliant_module as _gdcm,
+                        get_db_helper as _gdh)
+
+def get_dbapi_compliant_module(driver, *args, **kwargs):
+    module = _gdcm(driver, *args, **kwargs)
+    module.adv_func_helper = _gdh(driver)
+    return module