openerp/tools/misc.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
   6 #    Copyright (C) 2010-2014 OpenERP s.a. (<http://openerp.com>).
   7 #
   8 #    This program is free software: you can redistribute it and/or modify
   9 #    it under the terms of the GNU Affero General Public License as
  10 #    published by the Free Software Foundation, either version 3 of the
  11 #    License, or (at your option) any later version.
  12 #
  13 #    This program is distributed in the hope that it will be useful,
  14 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 #    GNU Affero General Public License for more details.
  17 #
  18 #    You should have received a copy of the GNU Affero General Public License
  19 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 #
  21 ##############################################################################
  22
  23
  24 """
  25 Miscellaneous tools used by OpenERP.
  26 """
  27
  28 from functools import wraps
  29 import cProfile
  30 import subprocess
  31 import logging
  32 import os
  33 import socket
  34 import sys
  35 import threading
  36 import time
  37 import zipfile
  38 from collections import defaultdict, Mapping
  39 from datetime import datetime
  40 from itertools import islice, izip, groupby
  41 from lxml import etree
  42 from which import which
  43 from threading import local
  44 import traceback
  45
  46 try:
  47     from html2text import html2text
  48 except ImportError:
  49     html2text = None
  50
  51 from config import config
  52 from cache import *
  53
  54 import openerp
  55 # get_encodings, ustr and exception_to_unicode were originally from tools.misc.
  56 # There are moved to loglevels until we refactor tools.
  57 from openerp.loglevels import get_encodings, ustr, exception_to_unicode     # noqa
  58
  59 _logger = logging.getLogger(__name__)
  60
  61 # List of etree._Element subclasses that we choose to ignore when parsing XML.
  62 # We include the *Base ones just in case, currently they seem to be subclasses of the _* ones.
  63 SKIPPED_ELEMENT_TYPES = (etree._Comment, etree._ProcessingInstruction, etree.CommentBase, etree.PIBase)
  64
  65 def find_in_path(name):
  66     try:
  67         return which(name)
  68     except IOError:
  69         return None
  70
  71 def find_pg_tool(name):
  72     path = None
  73     if config['pg_path'] and config['pg_path'] != 'None':
  74         path = config['pg_path']
  75     try:
  76         return which(name, path=path)
  77     except IOError:
  78         return None
  79
  80 def exec_pg_command(name, *args):
  81     prog = find_pg_tool(name)
  82     if not prog:
  83         raise Exception('Couldn\'t find %s' % name)
  84     args2 = (prog,) + args
  85
  86     with open(os.devnull) as dn:
  87         return subprocess.call(args2, stdout=dn, stderr=subprocess.STDOUT)
  88
  89 def exec_pg_command_pipe(name, *args):
  90     prog = find_pg_tool(name)
  91     if not prog:
  92         raise Exception('Couldn\'t find %s' % name)
  93     # on win32, passing close_fds=True is not compatible
  94     # with redirecting std[in/err/out]
  95     pop = subprocess.Popen((prog,) + args, bufsize= -1,
  96           stdin=subprocess.PIPE, stdout=subprocess.PIPE,
  97           close_fds=(os.name=="posix"))
  98     return pop.stdin, pop.stdout
  99
 100 def exec_command_pipe(name, *args):
 101     prog = find_in_path(name)
 102     if not prog:
 103         raise Exception('Couldn\'t find %s' % name)
 104     # on win32, passing close_fds=True is not compatible
 105     # with redirecting std[in/err/out]
 106     pop = subprocess.Popen((prog,) + args, bufsize= -1,
 107           stdin=subprocess.PIPE, stdout=subprocess.PIPE,
 108           close_fds=(os.name=="posix"))
 109     return pop.stdin, pop.stdout
 110
 111 #----------------------------------------------------------
 112 # File paths
 113 #----------------------------------------------------------
 114 #file_path_root = os.getcwd()
 115 #file_path_addons = os.path.join(file_path_root, 'addons')
 116
 117 def file_open(name, mode="r", subdir='addons', pathinfo=False):
 118     """Open a file from the OpenERP root, using a subdir folder.
 119
 120     Example::
 121
 122     >>> file_open('hr/report/timesheer.xsl')
 123     >>> file_open('addons/hr/report/timesheet.xsl')
 124     >>> file_open('../../base/report/rml_template.xsl', subdir='addons/hr/report', pathinfo=True)
 125
 126     @param name name of the file
 127     @param mode file open mode
 128     @param subdir subdirectory
 129     @param pathinfo if True returns tuple (fileobject, filepath)
 130
 131     @return fileobject if pathinfo is False else (fileobject, filepath)
 132     """
 133     import openerp.modules as addons
 134     adps = addons.module.ad_paths
 135     rtp = os.path.normcase(os.path.abspath(config['root_path']))
 136
 137     basename = name
 138
 139     if os.path.isabs(name):
 140         # It is an absolute path
 141         # Is it below 'addons_path' or 'root_path'?
 142         name = os.path.normcase(os.path.normpath(name))
 143         for root in adps + [rtp]:
 144             root = os.path.normcase(os.path.normpath(root)) + os.sep
 145             if name.startswith(root):
 146                 base = root.rstrip(os.sep)
 147                 name = name[len(base) + 1:]
 148                 break
 149         else:
 150             # It is outside the OpenERP root: skip zipfile lookup.
 151             base, name = os.path.split(name)
 152         return _fileopen(name, mode=mode, basedir=base, pathinfo=pathinfo, basename=basename)
 153
 154     if name.replace(os.sep, '/').startswith('addons/'):
 155         subdir = 'addons'
 156         name2 = name[7:]
 157     elif subdir:
 158         name = os.path.join(subdir, name)
 159         if name.replace(os.sep, '/').startswith('addons/'):
 160             subdir = 'addons'
 161             name2 = name[7:]
 162         else:
 163             name2 = name
 164
 165     # First, try to locate in addons_path
 166     if subdir:
 167         for adp in adps:
 168             try:
 169                 return _fileopen(name2, mode=mode, basedir=adp,
 170                                  pathinfo=pathinfo, basename=basename)
 171             except IOError:
 172                 pass
 173
 174     # Second, try to locate in root_path
 175     return _fileopen(name, mode=mode, basedir=rtp, pathinfo=pathinfo, basename=basename)
 176
 177
 178 def _fileopen(path, mode, basedir, pathinfo, basename=None):
 179     name = os.path.normpath(os.path.join(basedir, path))
 180
 181     if basename is None:
 182         basename = name
 183     # Give higher priority to module directories, which is
 184     # a more common case than zipped modules.
 185     if os.path.isfile(name):
 186         fo = open(name, mode)
 187         if pathinfo:
 188             return fo, name
 189         return fo
 190
 191     # Support for loading modules in zipped form.
 192     # This will not work for zipped modules that are sitting
 193     # outside of known addons paths.
 194     head = os.path.normpath(path)
 195     zipname = False
 196     while os.sep in head:
 197         head, tail = os.path.split(head)
 198         if not tail:
 199             break
 200         if zipname:
 201             zipname = os.path.join(tail, zipname)
 202         else:
 203             zipname = tail
 204         zpath = os.path.join(basedir, head + '.zip')
 205         if zipfile.is_zipfile(zpath):
 206             from cStringIO import StringIO
 207             zfile = zipfile.ZipFile(zpath)
 208             try:
 209                 fo = StringIO()
 210                 fo.write(zfile.read(os.path.join(
 211                     os.path.basename(head), zipname).replace(
 212                         os.sep, '/')))
 213                 fo.seek(0)
 214                 if pathinfo:
 215                     return fo, name
 216                 return fo
 217             except Exception:
 218                 pass
 219     # Not found
 220     if name.endswith('.rml'):
 221         raise IOError('Report %r doesn\'t exist or deleted' % basename)
 222     raise IOError('File not found: %s' % basename)
 223
 224
 225 #----------------------------------------------------------
 226 # iterables
 227 #----------------------------------------------------------
 228 def flatten(list):
 229     """Flatten a list of elements into a uniqu list
 230     Author: Christophe Simonis (christophe@tinyerp.com)
 231
 232     Examples::
 233     >>> flatten(['a'])
 234     ['a']
 235     >>> flatten('b')
 236     ['b']
 237     >>> flatten( [] )
 238     []
 239     >>> flatten( [[], [[]]] )
 240     []
 241     >>> flatten( [[['a','b'], 'c'], 'd', ['e', [], 'f']] )
 242     ['a', 'b', 'c', 'd', 'e', 'f']
 243     >>> t = (1,2,(3,), [4, 5, [6, [7], (8, 9), ([10, 11, (12, 13)]), [14, [], (15,)], []]])
 244     >>> flatten(t)
 245     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
 246     """
 247
 248     def isiterable(x):
 249         return hasattr(x, "__iter__")
 250
 251     r = []
 252     for e in list:
 253         if isiterable(e):
 254             map(r.append, flatten(e))
 255         else:
 256             r.append(e)
 257     return r
 258
 259 def reverse_enumerate(l):
 260     """Like enumerate but in the other sens
 261
 262     Usage::
 263     >>> a = ['a', 'b', 'c']
 264     >>> it = reverse_enumerate(a)
 265     >>> it.next()
 266     (2, 'c')
 267     >>> it.next()
 268     (1, 'b')
 269     >>> it.next()
 270     (0, 'a')
 271     >>> it.next()
 272     Traceback (most recent call last):
 273       File "<stdin>", line 1, in <module>
 274     StopIteration
 275     """
 276     return izip(xrange(len(l)-1, -1, -1), reversed(l))
 277
 278
 279 class UpdateableStr(local):
 280     """ Class that stores an updateable string (used in wizards)
 281     """
 282
 283     def __init__(self, string=''):
 284         self.string = string
 285
 286     def __str__(self):
 287         return str(self.string)
 288
 289     def __repr__(self):
 290         return str(self.string)
 291
 292     def __nonzero__(self):
 293         return bool(self.string)
 294
 295
 296 class UpdateableDict(local):
 297     """Stores an updateable dict to use in wizards
 298     """
 299
 300     def __init__(self, dict=None):
 301         if dict is None:
 302             dict = {}
 303         self.dict = dict
 304
 305     def __str__(self):
 306         return str(self.dict)
 307
 308     def __repr__(self):
 309         return str(self.dict)
 310
 311     def clear(self):
 312         return self.dict.clear()
 313
 314     def keys(self):
 315         return self.dict.keys()
 316
 317     def __setitem__(self, i, y):
 318         self.dict.__setitem__(i, y)
 319
 320     def __getitem__(self, i):
 321         return self.dict.__getitem__(i)
 322
 323     def copy(self):
 324         return self.dict.copy()
 325
 326     def iteritems(self):
 327         return self.dict.iteritems()
 328
 329     def iterkeys(self):
 330         return self.dict.iterkeys()
 331
 332     def itervalues(self):
 333         return self.dict.itervalues()
 334
 335     def pop(self, k, d=None):
 336         return self.dict.pop(k, d)
 337
 338     def popitem(self):
 339         return self.dict.popitem()
 340
 341     def setdefault(self, k, d=None):
 342         return self.dict.setdefault(k, d)
 343
 344     def update(self, E, **F):
 345         return self.dict.update(E, F)
 346
 347     def values(self):
 348         return self.dict.values()
 349
 350     def get(self, k, d=None):
 351         return self.dict.get(k, d)
 352
 353     def has_key(self, k):
 354         return self.dict.has_key(k)
 355
 356     def items(self):
 357         return self.dict.items()
 358
 359     def __cmp__(self, y):
 360         return self.dict.__cmp__(y)
 361
 362     def __contains__(self, k):
 363         return self.dict.__contains__(k)
 364
 365     def __delitem__(self, y):
 366         return self.dict.__delitem__(y)
 367
 368     def __eq__(self, y):
 369         return self.dict.__eq__(y)
 370
 371     def __ge__(self, y):
 372         return self.dict.__ge__(y)
 373
 374     def __gt__(self, y):
 375         return self.dict.__gt__(y)
 376
 377     def __hash__(self):
 378         return self.dict.__hash__()
 379
 380     def __iter__(self):
 381         return self.dict.__iter__()
 382
 383     def __le__(self, y):
 384         return self.dict.__le__(y)
 385
 386     def __len__(self):
 387         return self.dict.__len__()
 388
 389     def __lt__(self, y):
 390         return self.dict.__lt__(y)
 391
 392     def __ne__(self, y):
 393         return self.dict.__ne__(y)
 394
 395 class currency(float):
 396     """ Deprecate
 397
 398     .. warning::
 399
 400     Don't use ! Use res.currency.round()
 401     """
 402
 403     def __init__(self, value, accuracy=2, rounding=None):
 404         if rounding is None:
 405             rounding=10**-accuracy
 406         self.rounding=rounding
 407         self.accuracy=accuracy
 408
 409     def __new__(cls, value, accuracy=2, rounding=None):
 410         return float.__new__(cls, round(value, accuracy))
 411
 412     #def __str__(self):
 413     #   display_value = int(self*(10**(-self.accuracy))/self.rounding)*self.rounding/(10**(-self.accuracy))
 414     #   return str(display_value)
 415
 416 def to_xml(s):
 417     return s.replace('&','&amp;').replace('<','&lt;').replace('>','&gt;')
 418
 419 def get_iso_codes(lang):
 420     if lang.find('_') != -1:
 421         if lang.split('_')[0] == lang.split('_')[1].lower():
 422             lang = lang.split('_')[0]
 423     return lang
 424
 425 ALL_LANGUAGES = {
 426         'ab_RU': u'Abkhazian / аҧсуа',
 427         'am_ET': u'Amharic / አምሃርኛ',
 428         'ar_SY': u'Arabic / الْعَرَبيّة',
 429         'bg_BG': u'Bulgarian / български език',
 430         'bs_BS': u'Bosnian / bosanski jezik',
 431         'ca_ES': u'Catalan / Català',
 432         'cs_CZ': u'Czech / Čeština',
 433         'da_DK': u'Danish / Dansk',
 434         'de_DE': u'German / Deutsch',
 435         'el_GR': u'Greek / Ελληνικά',
 436         'en_CA': u'English (CA)',
 437         'en_GB': u'English (UK)',
 438         'en_US': u'English (US)',
 439         'es_AR': u'Spanish (AR) / Español (AR)',
 440         'es_BO': u'Spanish (BO) / Español (BO)',
 441         'es_CL': u'Spanish (CL) / Español (CL)',
 442         'es_CO': u'Spanish (CO) / Español (CO)',
 443         'es_CR': u'Spanish (CR) / Español (CR)',
 444         'es_DO': u'Spanish (DO) / Español (DO)',
 445         'es_EC': u'Spanish (EC) / Español (EC)',
 446         'es_ES': u'Spanish / Español',
 447         'es_GT': u'Spanish (GT) / Español (GT)',
 448         'es_HN': u'Spanish (HN) / Español (HN)',
 449         'es_MX': u'Spanish (MX) / Español (MX)',
 450         'es_NI': u'Spanish (NI) / Español (NI)',
 451         'es_PA': u'Spanish (PA) / Español (PA)',
 452         'es_PE': u'Spanish (PE) / Español (PE)',
 453         'es_PR': u'Spanish (PR) / Español (PR)',
 454         'es_PY': u'Spanish (PY) / Español (PY)',
 455         'es_SV': u'Spanish (SV) / Español (SV)',
 456         'es_UY': u'Spanish (UY) / Español (UY)',
 457         'es_VE': u'Spanish (VE) / Español (VE)',
 458         'et_EE': u'Estonian / Eesti keel',
 459         'fa_IR': u'Persian / فارس',
 460         'fi_FI': u'Finnish / Suomi',
 461         'fr_BE': u'French (BE) / Français (BE)',
 462         'fr_CH': u'French (CH) / Français (CH)',
 463         'fr_FR': u'French / Français',
 464         'gl_ES': u'Galician / Galego',
 465         'gu_IN': u'Gujarati / ગુજરાતી',
 466         'he_IL': u'Hebrew / עִבְרִי',
 467         'hi_IN': u'Hindi / हिंदी',
 468         'hr_HR': u'Croatian / hrvatski jezik',
 469         'hu_HU': u'Hungarian / Magyar',
 470         'id_ID': u'Indonesian / Bahasa Indonesia',
 471         'it_IT': u'Italian / Italiano',
 472         'iu_CA': u'Inuktitut / ᐃᓄᒃᑎᑐᑦ',
 473         'ja_JP': u'Japanese / 日本語',
 474         'ko_KP': u'Korean (KP) / 한국어 (KP)',
 475         'ko_KR': u'Korean (KR) / 한국어 (KR)',
 476         'lo_LA': u'Lao / ພາສາລາວ',
 477         'lt_LT': u'Lithuanian / Lietuvių kalba',
 478         'lv_LV': u'Latvian / latviešu valoda',
 479         'ml_IN': u'Malayalam / മലയാളം',
 480         'mn_MN': u'Mongolian / монгол',
 481         'nb_NO': u'Norwegian Bokmål / Norsk bokmål',
 482         'nl_NL': u'Dutch / Nederlands',
 483         'nl_BE': u'Flemish (BE) / Vlaams (BE)',
 484         'oc_FR': u'Occitan (FR, post 1500) / Occitan',
 485         'pl_PL': u'Polish / Język polski',
 486         'pt_BR': u'Portuguese (BR) / Português (BR)',
 487         'pt_PT': u'Portuguese / Português',
 488         'ro_RO': u'Romanian / română',
 489         'ru_RU': u'Russian / русский язык',
 490         'si_LK': u'Sinhalese / සිංහල',
 491         'sl_SI': u'Slovenian / slovenščina',
 492         'sk_SK': u'Slovak / Slovenský jazyk',
 493         'sq_AL': u'Albanian / Shqip',
 494         'sr_RS': u'Serbian (Cyrillic) / српски',
 495         'sr@latin': u'Serbian (Latin) / srpski',
 496         'sv_SE': u'Swedish / svenska',
 497         'te_IN': u'Telugu / తెలుగు',
 498         'tr_TR': u'Turkish / Türkçe',
 499         'vi_VN': u'Vietnamese / Tiếng Việt',
 500         'uk_UA': u'Ukrainian / українська',
 501         'ur_PK': u'Urdu / اردو',
 502         'zh_CN': u'Chinese (CN) / 简体中文',
 503         'zh_HK': u'Chinese (HK)',
 504         'zh_TW': u'Chinese (TW) / 正體字',
 505         'th_TH': u'Thai / ภาษาไทย',
 506         'tlh_TLH': u'Klingon',
 507     }
 508
 509 def scan_languages():
 510     """ Returns all languages supported by OpenERP for translation
 511
 512     :returns: a list of (lang_code, lang_name) pairs
 513     :rtype: [(str, unicode)]
 514     """
 515     return sorted(ALL_LANGUAGES.iteritems(), key=lambda k: k[1])
 516
 517 def get_user_companies(cr, user):
 518     def _get_company_children(cr, ids):
 519         if not ids:
 520             return []
 521         cr.execute('SELECT id FROM res_company WHERE parent_id IN %s', (tuple(ids),))
 522         res = [x[0] for x in cr.fetchall()]
 523         res.extend(_get_company_children(cr, res))
 524         return res
 525     cr.execute('SELECT company_id FROM res_users WHERE id=%s', (user,))
 526     user_comp = cr.fetchone()[0]
 527     if not user_comp:
 528         return []
 529     return [user_comp] + _get_company_children(cr, [user_comp])
 530
 531 def mod10r(number):
 532     """
 533     Input number : account or invoice number
 534     Output return: the same number completed with the recursive mod10
 535     key
 536     """
 537     codec=[0,9,4,6,8,2,7,1,3,5]
 538     report = 0
 539     result=""
 540     for digit in number:
 541         result += digit
 542         if digit.isdigit():
 543             report = codec[ (int(digit) + report) % 10 ]
 544     return result + str((10 - report) % 10)
 545
 546
 547 def human_size(sz):
 548     """
 549     Return the size in a human readable format
 550     """
 551     if not sz:
 552         return False
 553     units = ('bytes', 'Kb', 'Mb', 'Gb')
 554     if isinstance(sz,basestring):
 555         sz=len(sz)
 556     s, i = float(sz), 0
 557     while s >= 1024 and i < len(units)-1:
 558         s /= 1024
 559         i += 1
 560     return "%0.2f %s" % (s, units[i])
 561
 562 def logged(f):
 563     @wraps(f)
 564     def wrapper(*args, **kwargs):
 565         from pprint import pformat
 566
 567         vector = ['Call -> function: %r' % f]
 568         for i, arg in enumerate(args):
 569             vector.append('  arg %02d: %s' % (i, pformat(arg)))
 570         for key, value in kwargs.items():
 571             vector.append('  kwarg %10s: %s' % (key, pformat(value)))
 572
 573         timeb4 = time.time()
 574         res = f(*args, **kwargs)
 575
 576         vector.append('  result: %s' % pformat(res))
 577         vector.append('  time delta: %s' % (time.time() - timeb4))
 578         _logger.debug('\n'.join(vector))
 579         return res
 580
 581     return wrapper
 582
 583 class profile(object):
 584     def __init__(self, fname=None):
 585         self.fname = fname
 586
 587     def __call__(self, f):
 588         @wraps(f)
 589         def wrapper(*args, **kwargs):
 590             profile = cProfile.Profile()
 591             result = profile.runcall(f, *args, **kwargs)
 592             profile.dump_stats(self.fname or ("%s.cprof" % (f.func_name,)))
 593             return result
 594
 595         return wrapper
 596
 597 __icons_list = ['STOCK_ABOUT', 'STOCK_ADD', 'STOCK_APPLY', 'STOCK_BOLD',
 598 'STOCK_CANCEL', 'STOCK_CDROM', 'STOCK_CLEAR', 'STOCK_CLOSE', 'STOCK_COLOR_PICKER',
 599 'STOCK_CONNECT', 'STOCK_CONVERT', 'STOCK_COPY', 'STOCK_CUT', 'STOCK_DELETE',
 600 'STOCK_DIALOG_AUTHENTICATION', 'STOCK_DIALOG_ERROR', 'STOCK_DIALOG_INFO',
 601 'STOCK_DIALOG_QUESTION', 'STOCK_DIALOG_WARNING', 'STOCK_DIRECTORY', 'STOCK_DISCONNECT',
 602 'STOCK_DND', 'STOCK_DND_MULTIPLE', 'STOCK_EDIT', 'STOCK_EXECUTE', 'STOCK_FILE',
 603 'STOCK_FIND', 'STOCK_FIND_AND_REPLACE', 'STOCK_FLOPPY', 'STOCK_GOTO_BOTTOM',
 604 'STOCK_GOTO_FIRST', 'STOCK_GOTO_LAST', 'STOCK_GOTO_TOP', 'STOCK_GO_BACK',
 605 'STOCK_GO_DOWN', 'STOCK_GO_FORWARD', 'STOCK_GO_UP', 'STOCK_HARDDISK',
 606 'STOCK_HELP', 'STOCK_HOME', 'STOCK_INDENT', 'STOCK_INDEX', 'STOCK_ITALIC',
 607 'STOCK_JUMP_TO', 'STOCK_JUSTIFY_CENTER', 'STOCK_JUSTIFY_FILL',
 608 'STOCK_JUSTIFY_LEFT', 'STOCK_JUSTIFY_RIGHT', 'STOCK_MEDIA_FORWARD',
 609 'STOCK_MEDIA_NEXT', 'STOCK_MEDIA_PAUSE', 'STOCK_MEDIA_PLAY',
 610 'STOCK_MEDIA_PREVIOUS', 'STOCK_MEDIA_RECORD', 'STOCK_MEDIA_REWIND',
 611 'STOCK_MEDIA_STOP', 'STOCK_MISSING_IMAGE', 'STOCK_NETWORK', 'STOCK_NEW',
 612 'STOCK_NO', 'STOCK_OK', 'STOCK_OPEN', 'STOCK_PASTE', 'STOCK_PREFERENCES',
 613 'STOCK_PRINT', 'STOCK_PRINT_PREVIEW', 'STOCK_PROPERTIES', 'STOCK_QUIT',
 614 'STOCK_REDO', 'STOCK_REFRESH', 'STOCK_REMOVE', 'STOCK_REVERT_TO_SAVED',
 615 'STOCK_SAVE', 'STOCK_SAVE_AS', 'STOCK_SELECT_COLOR', 'STOCK_SELECT_FONT',
 616 'STOCK_SORT_ASCENDING', 'STOCK_SORT_DESCENDING', 'STOCK_SPELL_CHECK',
 617 'STOCK_STOP', 'STOCK_STRIKETHROUGH', 'STOCK_UNDELETE', 'STOCK_UNDERLINE',
 618 'STOCK_UNDO', 'STOCK_UNINDENT', 'STOCK_YES', 'STOCK_ZOOM_100',
 619 'STOCK_ZOOM_FIT', 'STOCK_ZOOM_IN', 'STOCK_ZOOM_OUT',
 620 'terp-account', 'terp-crm', 'terp-mrp', 'terp-product', 'terp-purchase',
 621 'terp-sale', 'terp-tools', 'terp-administration', 'terp-hr', 'terp-partner',
 622 'terp-project', 'terp-report', 'terp-stock', 'terp-calendar', 'terp-graph',
 623 'terp-check','terp-go-month','terp-go-year','terp-go-today','terp-document-new','terp-camera_test',
 624 'terp-emblem-important','terp-gtk-media-pause','terp-gtk-stop','terp-gnome-cpu-frequency-applet+',
 625 'terp-dialog-close','terp-gtk-jump-to-rtl','terp-gtk-jump-to-ltr','terp-accessories-archiver',
 626 'terp-stock_align_left_24','terp-stock_effects-object-colorize','terp-go-home','terp-gtk-go-back-rtl',
 627 'terp-gtk-go-back-ltr','terp-personal','terp-personal-','terp-personal+','terp-accessories-archiver-minus',
 628 'terp-accessories-archiver+','terp-stock_symbol-selection','terp-call-start','terp-dolar',
 629 'terp-face-plain','terp-folder-blue','terp-folder-green','terp-folder-orange','terp-folder-yellow',
 630 'terp-gdu-smart-failing','terp-go-week','terp-gtk-select-all','terp-locked','terp-mail-forward',
 631 'terp-mail-message-new','terp-mail-replied','terp-rating-rated','terp-stage','terp-stock_format-scientific',
 632 'terp-dolar_ok!','terp-idea','terp-stock_format-default','terp-mail-','terp-mail_delete'
 633 ]
 634
 635 def icons(*a, **kw):
 636     global __icons_list
 637     return [(x, x) for x in __icons_list ]
 638
 639 def detect_ip_addr():
 640     """Try a very crude method to figure out a valid external
 641        IP or hostname for the current machine. Don't rely on this
 642        for binding to an interface, but it could be used as basis
 643        for constructing a remote URL to the server.
 644     """
 645     def _detect_ip_addr():
 646         from array import array
 647         from struct import pack, unpack
 648
 649         try:
 650             import fcntl
 651         except ImportError:
 652             fcntl = None
 653
 654         ip_addr = None
 655
 656         if not fcntl: # not UNIX:
 657             host = socket.gethostname()
 658             ip_addr = socket.gethostbyname(host)
 659         else: # UNIX:
 660             # get all interfaces:
 661             nbytes = 128 * 32
 662             s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 663             names = array('B', '\0' * nbytes)
 664             #print 'names: ', names
 665             outbytes = unpack('iL', fcntl.ioctl( s.fileno(), 0x8912, pack('iL', nbytes, names.buffer_info()[0])))[0]
 666             namestr = names.tostring()
 667
 668             # try 64 bit kernel:
 669             for i in range(0, outbytes, 40):
 670                 name = namestr[i:i+16].split('\0', 1)[0]
 671                 if name != 'lo':
 672                     ip_addr = socket.inet_ntoa(namestr[i+20:i+24])
 673                     break
 674
 675             # try 32 bit kernel:
 676             if ip_addr is None:
 677                 ifaces = filter(None, [namestr[i:i+32].split('\0', 1)[0] for i in range(0, outbytes, 32)])
 678
 679                 for ifname in [iface for iface in ifaces if iface != 'lo']:
 680                     ip_addr = socket.inet_ntoa(fcntl.ioctl(s.fileno(), 0x8915, pack('256s', ifname[:15]))[20:24])
 681                     break
 682
 683         return ip_addr or 'localhost'
 684
 685     try:
 686         ip_addr = _detect_ip_addr()
 687     except Exception:
 688         ip_addr = 'localhost'
 689     return ip_addr
 690
 691 # RATIONALE BEHIND TIMESTAMP CALCULATIONS AND TIMEZONE MANAGEMENT:
 692 #  The server side never does any timestamp calculation, always
 693 #  sends them in a naive (timezone agnostic) format supposed to be
 694 #  expressed within the server timezone, and expects the clients to
 695 #  provide timestamps in the server timezone as well.
 696 #  It stores all timestamps in the database in naive format as well,
 697 #  which also expresses the time in the server timezone.
 698 #  For this reason the server makes its timezone name available via the
 699 #  common/timezone_get() rpc method, which clients need to read
 700 #  to know the appropriate time offset to use when reading/writing
 701 #  times.
 702 def get_win32_timezone():
 703     """Attempt to return the "standard name" of the current timezone on a win32 system.
 704        @return the standard name of the current win32 timezone, or False if it cannot be found.
 705     """
 706     res = False
 707     if sys.platform == "win32":
 708         try:
 709             import _winreg
 710             hklm = _winreg.ConnectRegistry(None,_winreg.HKEY_LOCAL_MACHINE)
 711             current_tz_key = _winreg.OpenKey(hklm, r"SYSTEM\CurrentControlSet\Control\TimeZoneInformation", 0,_winreg.KEY_ALL_ACCESS)
 712             res = str(_winreg.QueryValueEx(current_tz_key,"StandardName")[0])  # [0] is value, [1] is type code
 713             _winreg.CloseKey(current_tz_key)
 714             _winreg.CloseKey(hklm)
 715         except Exception:
 716             pass
 717     return res
 718
 719 def detect_server_timezone():
 720     """Attempt to detect the timezone to use on the server side.
 721        Defaults to UTC if no working timezone can be found.
 722        @return the timezone identifier as expected by pytz.timezone.
 723     """
 724     try:
 725         import pytz
 726     except Exception:
 727         _logger.warning("Python pytz module is not available. "
 728             "Timezone will be set to UTC by default.")
 729         return 'UTC'
 730
 731     # Option 1: the configuration option (did not exist before, so no backwards compatibility issue)
 732     # Option 2: to be backwards compatible with 5.0 or earlier, the value from time.tzname[0], but only if it is known to pytz
 733     # Option 3: the environment variable TZ
 734     sources = [ (config['timezone'], 'OpenERP configuration'),
 735                 (time.tzname[0], 'time.tzname'),
 736                 (os.environ.get('TZ',False),'TZ environment variable'), ]
 737     # Option 4: OS-specific: /etc/timezone on Unix
 738     if os.path.exists("/etc/timezone"):
 739         tz_value = False
 740         try:
 741             f = open("/etc/timezone")
 742             tz_value = f.read(128).strip()
 743         except Exception:
 744             pass
 745         finally:
 746             f.close()
 747         sources.append((tz_value,"/etc/timezone file"))
 748     # Option 5: timezone info from registry on Win32
 749     if sys.platform == "win32":
 750         # Timezone info is stored in windows registry.
 751         # However this is not likely to work very well as the standard name
 752         # of timezones in windows is rarely something that is known to pytz.
 753         # But that's ok, it is always possible to use a config option to set
 754         # it explicitly.
 755         sources.append((get_win32_timezone(),"Windows Registry"))
 756
 757     for (value,source) in sources:
 758         if value:
 759             try:
 760                 tz = pytz.timezone(value)
 761                 _logger.info("Using timezone %s obtained from %s.", tz.zone, source)
 762                 return value
 763             except pytz.UnknownTimeZoneError:
 764                 _logger.warning("The timezone specified in %s (%s) is invalid, ignoring it.", source, value)
 765
 766     _logger.warning("No valid timezone could be detected, using default UTC "
 767         "timezone. You can specify it explicitly with option 'timezone' in "
 768         "the server configuration.")
 769     return 'UTC'
 770
 771 def get_server_timezone():
 772     return "UTC"
 773
 774
 775 DEFAULT_SERVER_DATE_FORMAT = "%Y-%m-%d"
 776 DEFAULT_SERVER_TIME_FORMAT = "%H:%M:%S"
 777 DEFAULT_SERVER_DATETIME_FORMAT = "%s %s" % (
 778     DEFAULT_SERVER_DATE_FORMAT,
 779     DEFAULT_SERVER_TIME_FORMAT)
 780
 781 # Python's strftime supports only the format directives
 782 # that are available on the platform's libc, so in order to
 783 # be cross-platform we map to the directives required by
 784 # the C standard (1989 version), always available on platforms
 785 # with a C standard implementation.
 786 DATETIME_FORMATS_MAP = {
 787         '%C': '', # century
 788         '%D': '%m/%d/%Y', # modified %y->%Y
 789         '%e': '%d',
 790         '%E': '', # special modifier
 791         '%F': '%Y-%m-%d',
 792         '%g': '%Y', # modified %y->%Y
 793         '%G': '%Y',
 794         '%h': '%b',
 795         '%k': '%H',
 796         '%l': '%I',
 797         '%n': '\n',
 798         '%O': '', # special modifier
 799         '%P': '%p',
 800         '%R': '%H:%M',
 801         '%r': '%I:%M:%S %p',
 802         '%s': '', #num of seconds since epoch
 803         '%T': '%H:%M:%S',
 804         '%t': ' ', # tab
 805         '%u': ' %w',
 806         '%V': '%W',
 807         '%y': '%Y', # Even if %y works, it's ambiguous, so we should use %Y
 808         '%+': '%Y-%m-%d %H:%M:%S',
 809
 810         # %Z is a special case that causes 2 problems at least:
 811         #  - the timezone names we use (in res_user.context_tz) come
 812         #    from pytz, but not all these names are recognized by
 813         #    strptime(), so we cannot convert in both directions
 814         #    when such a timezone is selected and %Z is in the format
 815         #  - %Z is replaced by an empty string in strftime() when
 816         #    there is not tzinfo in a datetime value (e.g when the user
 817         #    did not pick a context_tz). The resulting string does not
 818         #    parse back if the format requires %Z.
 819         # As a consequence, we strip it completely from format strings.
 820         # The user can always have a look at the context_tz in
 821         # preferences to check the timezone.
 822         '%z': '',
 823         '%Z': '',
 824 }
 825
 826 POSIX_TO_LDML = {
 827     'a': 'E',
 828     'A': 'EEEE',
 829     'b': 'MMM',
 830     'B': 'MMMM',
 831     #'c': '',
 832     'd': 'dd',
 833     'H': 'HH',
 834     'I': 'hh',
 835     'j': 'DDD',
 836     'm': 'MM',
 837     'M': 'mm',
 838     'p': 'a',
 839     'S': 'ss',
 840     'U': 'w',
 841     'w': 'e',
 842     'W': 'w',
 843     'y': 'yy',
 844     'Y': 'yyyy',
 845     # see comments above, and babel's format_datetime assumes an UTC timezone
 846     # for naive datetime objects
 847     #'z': 'Z',
 848     #'Z': 'z',
 849 }
 850
 851 def posix_to_ldml(fmt, locale):
 852     """ Converts a posix/strftime pattern into an LDML date format pattern.
 853
 854     :param fmt: non-extended C89/C90 strftime pattern
 855     :param locale: babel locale used for locale-specific conversions (e.g. %x and %X)
 856     :return: unicode
 857     """
 858     buf = []
 859     pc = False
 860     quoted = []
 861
 862     for c in fmt:
 863         # LDML date format patterns uses letters, so letters must be quoted
 864         if not pc and c.isalpha():
 865             quoted.append(c if c != "'" else "''")
 866             continue
 867         if quoted:
 868             buf.append("'")
 869             buf.append(''.join(quoted))
 870             buf.append("'")
 871             quoted = []
 872
 873         if pc:
 874             if c == '%': # escaped percent
 875                 buf.append('%')
 876             elif c == 'x': # date format, short seems to match
 877                 buf.append(locale.date_formats['short'].pattern)
 878             elif c == 'X': # time format, seems to include seconds. short does not
 879                 buf.append(locale.time_formats['medium'].pattern)
 880             else: # look up format char in static mapping
 881                 buf.append(POSIX_TO_LDML[c])
 882             pc = False
 883         elif c == '%':
 884             pc = True
 885         else:
 886             buf.append(c)
 887
 888     # flush anything remaining in quoted buffer
 889     if quoted:
 890         buf.append("'")
 891         buf.append(''.join(quoted))
 892         buf.append("'")
 893
 894     return ''.join(buf)
 895
 896 def server_to_local_timestamp(src_tstamp_str, src_format, dst_format, dst_tz_name,
 897         tz_offset=True, ignore_unparsable_time=True):
 898     """
 899     Convert a source timestamp string into a destination timestamp string, attempting to apply the
 900     correct offset if both the server and local timezone are recognized, or no
 901     offset at all if they aren't or if tz_offset is false (i.e. assuming they are both in the same TZ).
 902
 903     WARNING: This method is here to allow formatting dates correctly for inclusion in strings where
 904              the client would not be able to format/offset it correctly. DO NOT use it for returning
 905              date fields directly, these are supposed to be handled by the client!!
 906
 907     @param src_tstamp_str: the str value containing the timestamp in the server timezone.
 908     @param src_format: the format to use when parsing the server timestamp.
 909     @param dst_format: the format to use when formatting the resulting timestamp for the local/client timezone.
 910     @param dst_tz_name: name of the destination timezone (such as the 'tz' value of the client context)
 911     @param ignore_unparsable_time: if True, return False if src_tstamp_str cannot be parsed
 912                                    using src_format or formatted using dst_format.
 913
 914     @return local/client formatted timestamp, expressed in the local/client timezone if possible
 915             and if tz_offset is true, or src_tstamp_str if timezone offset could not be determined.
 916     """
 917     if not src_tstamp_str:
 918         return False
 919
 920     res = src_tstamp_str
 921     if src_format and dst_format:
 922         # find out server timezone
 923         server_tz = get_server_timezone()
 924         try:
 925             # dt_value needs to be a datetime.datetime object (so no time.struct_time or mx.DateTime.DateTime here!)
 926             dt_value = datetime.strptime(src_tstamp_str, src_format)
 927             if tz_offset and dst_tz_name:
 928                 try:
 929                     import pytz
 930                     src_tz = pytz.timezone(server_tz)
 931                     dst_tz = pytz.timezone(dst_tz_name)
 932                     src_dt = src_tz.localize(dt_value, is_dst=True)
 933                     dt_value = src_dt.astimezone(dst_tz)
 934                 except Exception:
 935                     pass
 936             res = dt_value.strftime(dst_format)
 937         except Exception:
 938             # Normal ways to end up here are if strptime or strftime failed
 939             if not ignore_unparsable_time:
 940                 return False
 941     return res
 942
 943
 944 def split_every(n, iterable, piece_maker=tuple):
 945     """Splits an iterable into length-n pieces. The last piece will be shorter
 946        if ``n`` does not evenly divide the iterable length.
 947        @param ``piece_maker``: function to build the pieces
 948        from the slices (tuple,list,...)
 949     """
 950     iterator = iter(iterable)
 951     piece = piece_maker(islice(iterator, n))
 952     while piece:
 953         yield piece
 954         piece = piece_maker(islice(iterator, n))
 955
 956 if __name__ == '__main__':
 957     import doctest
 958     doctest.testmod()
 959
 960 class upload_data_thread(threading.Thread):
 961     def __init__(self, email, data, type):
 962         self.args = [('email',email),('type',type),('data',data)]
 963         super(upload_data_thread,self).__init__()
 964     def run(self):
 965         try:
 966             import urllib
 967             args = urllib.urlencode(self.args)
 968             fp = urllib.urlopen('http://www.openerp.com/scripts/survey.php', args)
 969             fp.read()
 970             fp.close()
 971         except Exception:
 972             pass
 973
 974 def upload_data(email, data, type='SURVEY'):
 975     a = upload_data_thread(email, data, type)
 976     a.start()
 977     return True
 978
 979 def get_and_group_by_field(cr, uid, obj, ids, field, context=None):
 980     """ Read the values of ``field´´ for the given ``ids´´ and group ids by value.
 981
 982        :param string field: name of the field we want to read and group by
 983        :return: mapping of field values to the list of ids that have it
 984        :rtype: dict
 985     """
 986     res = {}
 987     for record in obj.read(cr, uid, ids, [field], context=context):
 988         key = record[field]
 989         res.setdefault(key[0] if isinstance(key, tuple) else key, []).append(record['id'])
 990     return res
 991
 992 def get_and_group_by_company(cr, uid, obj, ids, context=None):
 993     return get_and_group_by_field(cr, uid, obj, ids, field='company_id', context=context)
 994
 995 # port of python 2.6's attrgetter with support for dotted notation
 996 def resolve_attr(obj, attr):
 997     for name in attr.split("."):
 998         obj = getattr(obj, name)
 999     return obj
1000
1001 def attrgetter(*items):
1002     if len(items) == 1:
1003         attr = items[0]
1004         def g(obj):
1005             return resolve_attr(obj, attr)
1006     else:
1007         def g(obj):
1008             return tuple(resolve_attr(obj, attr) for attr in items)
1009     return g
1010
1011 class unquote(str):
1012     """A subclass of str that implements repr() without enclosing quotation marks
1013        or escaping, keeping the original string untouched. The name come from Lisp's unquote.
1014        One of the uses for this is to preserve or insert bare variable names within dicts during eval()
1015        of a dict's repr(). Use with care.
1016
1017        Some examples (notice that there are never quotes surrounding
1018        the ``active_id`` name:
1019
1020        >>> unquote('active_id')
1021        active_id
1022        >>> d = {'test': unquote('active_id')}
1023        >>> d
1024        {'test': active_id}
1025        >>> print d
1026        {'test': active_id}
1027     """
1028     def __repr__(self):
1029         return self
1030
1031 class UnquoteEvalContext(defaultdict):
1032     """Defaultdict-based evaluation context that returns
1033        an ``unquote`` string for any missing name used during
1034        the evaluation.
1035        Mostly useful for evaluating OpenERP domains/contexts that
1036        may refer to names that are unknown at the time of eval,
1037        so that when the context/domain is converted back to a string,
1038        the original names are preserved.
1039
1040        **Warning**: using an ``UnquoteEvalContext`` as context for ``eval()`` or
1041        ``safe_eval()`` will shadow the builtins, which may cause other
1042        failures, depending on what is evaluated.
1043
1044        Example (notice that ``section_id`` is preserved in the final
1045        result) :
1046
1047        >>> context_str = "{'default_user_id': uid, 'default_section_id': section_id}"
1048        >>> eval(context_str, UnquoteEvalContext(uid=1))
1049        {'default_user_id': 1, 'default_section_id': section_id}
1050
1051        """
1052     def __init__(self, *args, **kwargs):
1053         super(UnquoteEvalContext, self).__init__(None, *args, **kwargs)
1054
1055     def __missing__(self, key):
1056         return unquote(key)
1057
1058
1059 class mute_logger(object):
1060     """Temporary suppress the logging.
1061     Can be used as context manager or decorator.
1062
1063         @mute_logger('openerp.plic.ploc')
1064         def do_stuff():
1065             blahblah()
1066
1067         with mute_logger('openerp.foo.bar'):
1068             do_suff()
1069
1070     """
1071     def __init__(self, *loggers):
1072         self.loggers = loggers
1073
1074     def filter(self, record):
1075         return 0
1076
1077     def __enter__(self):
1078         for logger in self.loggers:
1079             assert isinstance(logger, basestring),\
1080                 "A logger name must be a string, got %s" % type(logger)
1081             logging.getLogger(logger).addFilter(self)
1082
1083     def __exit__(self, exc_type=None, exc_val=None, exc_tb=None):
1084         for logger in self.loggers:
1085             logging.getLogger(logger).removeFilter(self)
1086
1087     def __call__(self, func):
1088         @wraps(func)
1089         def deco(*args, **kwargs):
1090             with self:
1091                 return func(*args, **kwargs)
1092         return deco
1093
1094 _ph = object()
1095 class CountingStream(object):
1096     """ Stream wrapper counting the number of element it has yielded. Similar
1097     role to ``enumerate``, but for use when the iteration process of the stream
1098     isn't fully under caller control (the stream can be iterated from multiple
1099     points including within a library)
1100
1101     ``start`` allows overriding the starting index (the index before the first
1102     item is returned).
1103
1104     On each iteration (call to :meth:`~.next`), increases its :attr:`~.index`
1105     by one.
1106
1107     .. attribute:: index
1108
1109         ``int``, index of the last yielded element in the stream. If the stream
1110         has ended, will give an index 1-past the stream
1111     """
1112     def __init__(self, stream, start=-1):
1113         self.stream = iter(stream)
1114         self.index = start
1115         self.stopped = False
1116     def __iter__(self):
1117         return self
1118     def next(self):
1119         if self.stopped: raise StopIteration()
1120         self.index += 1
1121         val = next(self.stream, _ph)
1122         if val is _ph:
1123             self.stopped = True
1124             raise StopIteration()
1125         return val
1126
1127 def stripped_sys_argv(*strip_args):
1128     """Return sys.argv with some arguments stripped, suitable for reexecution or subprocesses"""
1129     strip_args = sorted(set(strip_args) | set(['-s', '--save', '-d', '--database', '-u', '--update', '-i', '--init']))
1130     assert all(config.parser.has_option(s) for s in strip_args)
1131     takes_value = dict((s, config.parser.get_option(s).takes_value()) for s in strip_args)
1132
1133     longs, shorts = list(tuple(y) for _, y in groupby(strip_args, lambda x: x.startswith('--')))
1134     longs_eq = tuple(l + '=' for l in longs if takes_value[l])
1135
1136     args = sys.argv[:]
1137
1138     def strip(args, i):
1139         return args[i].startswith(shorts) \
1140             or args[i].startswith(longs_eq) or (args[i] in longs) \
1141             or (i >= 1 and (args[i - 1] in strip_args) and takes_value[args[i - 1]])
1142
1143     return [x for i, x in enumerate(args) if not strip(args, i)]
1144
1145
1146 class ConstantMapping(Mapping):
1147     """
1148     An immutable mapping returning the provided value for every single key.
1149
1150     Useful for default value to methods
1151     """
1152     __slots__ = ['_value']
1153     def __init__(self, val):
1154         self._value = val
1155
1156     def __len__(self):
1157         """
1158         defaultdict updates its length for each individually requested key, is
1159         that really useful?
1160         """
1161         return 0
1162
1163     def __iter__(self):
1164         """
1165         same as len, defaultdict udpates its iterable keyset with each key
1166         requested, is there a point for this?
1167         """
1168         return iter([])
1169
1170     def __getitem__(self, item):
1171         return self._value
1172
1173
1174 def dumpstacks(sig, frame):
1175     """ Signal handler: dump a stack trace for each existing thread."""
1176     code = []
1177
1178     def extract_stack(stack):
1179         for filename, lineno, name, line in traceback.extract_stack(stack):
1180             yield 'File: "%s", line %d, in %s' % (filename, lineno, name)
1181             if line:
1182                 yield "  %s" % (line.strip(),)
1183
1184     # code from http://stackoverflow.com/questions/132058/getting-stack-trace-from-a-running-python-application#answer-2569696
1185     # modified for python 2.5 compatibility
1186     threads_info = dict([(th.ident, {'name': th.name, 'uid': getattr(th, 'uid', 'n/a')})
1187                         for th in threading.enumerate()])
1188     for threadId, stack in sys._current_frames().items():
1189         thread_info = threads_info.get(threadId)
1190         code.append("\n# Thread: %s (id:%s) (uid:%s)" %
1191                     (thread_info and thread_info['name'] or 'n/a',
1192                      threadId,
1193                      thread_info and thread_info['uid'] or 'n/a'))
1194         for line in extract_stack(stack):
1195             code.append(line)
1196
1197     if openerp.evented:
1198         # code from http://stackoverflow.com/questions/12510648/in-gevent-how-can-i-dump-stack-traces-of-all-running-greenlets
1199         import gc
1200         from greenlet import greenlet
1201         for ob in gc.get_objects():
1202             if not isinstance(ob, greenlet) or not ob:
1203                 continue
1204             code.append("\n# Greenlet: %r" % (ob,))
1205             for line in extract_stack(ob.gr_frame):
1206                 code.append(line)
1207
1208     _logger.info("\n".join(code))
1209
1210
1211
1212 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: