def test_deprecated_func(self):
any_func = deprecation.deprecated()(self.mk_func())
any_func()
any_func = deprecation.deprecated('message')(self.mk_func())
any_func()
self.assertEqual(self.messages,
['The function "any_func" is deprecated', 'message'])
['a']
>>>
:type string: str or unicode
:param string: a csv line
:type sep: str or unicode
:param sep: field separator, default to the comma (',')
:rtype: str or unicode
:return: the unquoted string (or the input string if it wasn't quoted)
"""
return [word.strip() for word in string.split(sep) if word.strip()]
get_csv = deprecated('get_csv is deprecated, use splitstrip')(splitstrip)
def split_url_or_path(url_or_path):
"""return the latest component of a string containing either an url of the
form <scheme>://<path> or a local file system path
"""
if '://' in url_or_path:
return url_or_path.rstrip('/').rsplit('/', 1)
return osp.split(url_or_path.rstrip(osp.sep))
def text_to_dict(text):
"""parse multilines text containing simple 'key=value' lines and return a
dict of {'key': 'value'}. When the same key is encountered multiple time,
value is turned into a list containing all values.
['a']
>>>
:type string: str or unicode
:param string: a csv line
:type sep: str or unicode
:param sep: field separator, default to the comma (',')
:rtype: str or unicode
:return: the unquoted string (or the input string if it wasn't quoted)
"""
return [word.strip() for word in string.split(sep) if word.strip()]
get_csv = deprecated("get_csv is deprecated, use splitstrip")(splitstrip)
def split_url_or_path(url_or_path):
"""return the latest component of a string containing either an url of the
form <scheme>://<path> or a local file system path
"""
if "://" in url_or_path:
return url_or_path.rstrip("/").rsplit("/", 1)
return osp.split(url_or_path.rstrip(osp.sep))
def text_to_dict(text):
"""parse multilines text containing simple 'key=value' lines and return a
dict of {'key': 'value'}. When the same key is encountered multiple time,
value is turned into a list containing all values.
def str_encode(string, encoding):
return str(string)
# See also http://bugs.python.org/issue11776
if sys.version_info[0] == 3:
def method_type(callable, instance, klass):
# api change. klass is no more considered
return types.MethodType(callable, instance)
else:
# alias types otherwise
method_type = types.MethodType
# Pythons 2 and 3 differ on where to get StringIO
if sys.version_info < (3, 0):
from cStringIO import StringIO
FileIO = file
BytesIO = StringIO
reload = reload
else:
from io import FileIO, BytesIO, StringIO
from imp import reload
from logilab.common.deprecation import deprecated
# Other projects import these from here, keep providing them for
# backwards compat
any = deprecated('use builtin "any"')(any)
all = deprecated('use builtin "all"')(all)
class Select(Statement, nodes.EditableMixIn, ScopeNode):
"""the select node is the base statement of the syntax tree for selection
statement, always child of a UNION root.
"""
vargraph = None
parent = None
distinct = False
# limit / offset
limit = None
offset = 0
# select clauses
groupby = ()
orderby = ()
with_ = ()
# set by the annotator
has_aggregat = False
def __init__(self):
Statement.__init__(self)
ScopeNode.__init__(self)
self.selection = []
# subqueries alias
self.aliases = {}
# syntax tree meta-information
self.stinfo = {'rewritten': {}}
@property
def root(self):
"""return the root node of the tree"""
return self.parent
def get_description(self, mainindex, tr):
"""return the list of types or relations (if not found) associated to
selected variables.
mainindex is an optional selection index which should be considered has
'pivot' entity.
"""
descr = []
for term in self.selection:
# don't translate Any
try:
descr.append(term.get_description(mainindex, tr) or 'Any')
except CoercionError:
descr.append('Any')
return descr
@property
def children(self):
children = self.selection[:]
if self.groupby:
children += self.groupby
if self.orderby:
children += self.orderby
if self.where:
children.append(self.where)
if self.having:
children += self.having
if self.with_:
children += self.with_
return children
# repr / as_string / copy #################################################
def __repr__(self):
return self.as_string(userepr=True)
def as_string(self, kwargs=None, userepr=False):
"""return the tree as an encoded rql string"""
if userepr:
as_string = repr
else:
def as_string(x):
return x.as_string(kwargs=kwargs)
s = [','.join(as_string(term) for term in self.selection)]
if self.groupby:
s.append('GROUPBY ' +
','.join(as_string(term) for term in self.groupby))
if self.orderby:
s.append('ORDERBY ' +
','.join(as_string(term) for term in self.orderby))
if self.limit is not None:
s.append('LIMIT %s' % self.limit)
if self.offset:
s.append('OFFSET %s' % self.offset)
if self.where is not None:
s.append('WHERE ' + as_string(self.where))
if self.having:
s.append('HAVING ' +
','.join(as_string(term) for term in self.having))
if self.with_:
s.append('WITH ' +
','.join(as_string(term) for term in self.with_))
if self.distinct:
return 'DISTINCT Any ' + ' '.join(s)
return 'Any ' + ' '.join(s)
def copy(self, copy_solutions=True, solutions=None):
new = ScopeNode.copy(self, copy_solutions, solutions)
if self.with_:
new.set_with([sq.copy(new) for sq in self.with_], check=False)
for child in self.selection:
new.append_selected(child.copy(new))
if self.groupby:
new.set_groupby([sq.copy(new) for sq in self.groupby])
if self.orderby:
new.set_orderby([sq.copy(new) for sq in self.orderby])
if self.where:
new.set_where(self.where.copy(new))
if self.having:
new.set_having([sq.copy(new) for sq in self.having])
new.distinct = self.distinct
new.limit = self.limit
new.offset = self.offset
new.vargraph = self.vargraph
return new
# select specific methods #################################################
def set_possible_types(self,
solutions,
kwargs=_MARKER,
key='possibletypes'):
super(Select, self).set_possible_types(solutions, kwargs, key)
for ca in self.aliases.values():
ca.stinfo[key] = capt = set()
for solution in solutions:
capt.add(solution[ca.name])
if kwargs is _MARKER:
continue
# propagage to subqueries in case we're introducing additional
# type constraints
for stmt in ca.query.children[:]:
term = stmt.selection[ca.colnum]
sols = [
sol for sol in stmt.solutions
if term.get_type(sol, kwargs) in capt
]
if not sols:
ca.query.remove_select(stmt)
else:
stmt.set_possible_types(sols)
def set_statement_type(self, etype):
"""set the statement type for this selection
this method must be called last (i.e. once selected variables has been
added)
"""
assert self.selection
# Person P -> Any P where P is Person
if etype != 'Any':
variables = list(self.get_selected_variables())
if not variables:
raise BadRQLQuery('Setting type in selection is only allowed '
'when some variable is selected')
for var in variables:
self.add_type_restriction(var.variable, etype)
def set_distinct(self, value):
"""mark DISTINCT query"""
if self.should_register_op and value != self.distinct:
from rql.undo import SetDistinctOperation
self.undo_manager.add_operation(
SetDistinctOperation(self.distinct, self))
self.distinct = value
def set_limit(self, limit):
if limit is not None and (not isinstance(limit, integer_types)
or limit <= 0):
raise BadRQLQuery('bad limit %s' % limit)
if self.should_register_op and limit != self.limit:
from rql.undo import SetLimitOperation
self.undo_manager.add_operation(SetLimitOperation(
self.limit, self))
self.limit = limit
def set_offset(self, offset):
if offset is not None and (not isinstance(offset, integer_types)
or offset < 0):
raise BadRQLQuery('bad offset %s' % offset)
if self.should_register_op and offset != self.offset:
from rql.undo import SetOffsetOperation
self.undo_manager.add_operation(
SetOffsetOperation(self.offset, self))
self.offset = offset
def set_orderby(self, terms):
self.orderby = terms
for node in terms:
node.parent = self
def set_groupby(self, terms):
self.groupby = terms
for node in terms:
node.parent = self
def set_with(self, terms, check=True):
self.with_ = []
for node in terms:
self.add_subquery(node, check)
def add_subquery(self, node, check=True):
assert node.query
if not isinstance(self.with_, list):
self.with_ = []
node.parent = self
self.with_.append(node)
if check and len(node.aliases) != len(
node.query.children[0].selection):
raise BadRQLQuery('Should have the same number of aliases than '
'selected terms in sub-query')
for i, alias in enumerate(node.aliases):
alias = alias.name
if check and alias in self.aliases:
raise BadRQLQuery('Duplicated alias %s' % alias)
ca = self.get_variable(alias, i)
ca.query = node.query
def remove_subquery(self, node):
self.with_.remove(node)
node.parent = None
for i, alias in enumerate(node.aliases):
del self.aliases[alias.name]
def get_variable(self, name, colnum=None):
"""get a variable instance from its name
the variable is created if it doesn't exist yet
"""
if name in self.aliases:
return self.aliases[name]
if colnum is not None: # take care, may be 0
self.aliases[name] = calias = nodes.ColumnAlias(name, colnum)
calias.stmt = self
# alias may already have been used as a regular variable, replace it
if name in self.defined_vars:
var = self.defined_vars.pop(name)
calias.stinfo['references'] = var.stinfo['references']
for vref in var.references():
vref.variable = calias
return self.aliases[name]
return super(Select, self).get_variable(name)
def clean_solutions(self, solutions=None):
"""when a rqlst has been extracted from another, this method returns
solutions which make sense for this sub syntax tree
"""
if solutions is None:
solutions = self.solutions
# this may occurs with rql optimization, for instance on
# 'Any X WHERE X eid 12' query
if not (self.defined_vars or self.aliases):
self.solutions = [{}]
else:
newsolutions = []
for origsol in solutions:
asol = {}
for var in self.defined_vars:
asol[var] = origsol[var]
for var in self.aliases:
asol[var] = origsol[var]
if asol not in newsolutions:
newsolutions.append(asol)
self.solutions = newsolutions
def get_selection_solutions(self):
"""return the set of variable names which take different type according
to the solutions
"""
descriptions = set()
for solution in self.solutions:
descr = []
for term in self.selection:
try:
descr.append(term.get_type(solution=solution))
except CoercionError:
pass
descriptions.add(tuple(descr))
return descriptions
# quick accessors #########################################################
def get_selected_variables(self):
"""returns all selected variables, including those used in aggregate
functions
"""
for term in self.selection:
for node in term.iget_nodes(nodes.VariableRef):
yield node
# construction helper methods #############################################
def save_state(self):
"""save the current tree"""
self.parent.save_state()
def recover(self):
"""reverts the tree as it was when save_state() was last called"""
self.parent.recover()
def append_selected(self, term):
if isinstance(term, nodes.Constant) and term.type == 'etype':
raise BadRQLQuery('Entity type are not allowed in selection')
term.parent = self
self.selection.append(term)
# XXX proprify edition, we should specify if we want:
# * undo support
# * references handling
def replace(self, oldnode, newnode):
if oldnode is self.where:
self.where = newnode
elif any(oldnode.is_equivalent(s) for s in self.selection):
index = next(i for i, s in enumerate(self.selection)
if oldnode.is_equivalent(s))
self.selection[index] = newnode
elif any(oldnode.is_equivalent(o) for o in self.orderby):
index = next(i for i, o in enumerate(self.orderby)
if oldnode.is_equivalent(o))
self.orderby[index] = newnode
elif any(oldnode.is_equivalent(g) for g in self.groupby):
index = next(i for i, g in enumerate(self.groupby)
if oldnode.is_equivalent(g))
self.groupby[index] = newnode
elif any(oldnode.is_equivalent(h) for h in self.having):
index = next(i for i, h in enumerate(self.having)
if oldnode.is_equivalent(h))
self.having[index] = newnode
else:
raise Exception('duh XXX %s' % oldnode)
# XXX no undo/reference support 'by design' (i.e. breaks things if you add
# it...)
oldnode.parent = None
newnode.parent = self
return oldnode, self, None
def remove(self, node):
if node is self.where:
self.where = None
elif any(node.is_equivalent(o) for o in self.orderby):
self.remove_sort_term(node)
elif any(node.is_equivalent(g) for g in self.groupby):
self.remove_group_term(node)
elif any(node.is_equivalent(h) for h in self.having):
self.having.remove(node)
# XXX selection
else:
raise Exception('duh XXX')
node.parent = None
return node, self, None
def undefine_variable(self, var):
"""undefine the given variable and remove all relations where it appears"""
if hasattr(var, 'variable'):
var = var.variable
# remove relations where this variable is referenced
for vref in var.references():
rel = vref.relation()
if rel is not None:
self.remove_node(rel)
# XXX may have other nodes between vref and the sort term
elif isinstance(vref.parent, nodes.SortTerm):
self.remove_sort_term(vref.parent)
elif vref in self.groupby:
self.remove_group_term(vref)
else: # selected variable
self.remove_selected(vref)
# effective undefine operation
if self.should_register_op:
from rql.undo import UndefineVarOperation
solutions = [d.copy() for d in self.solutions]
self.undo_manager.add_operation(
UndefineVarOperation(var, self, solutions))
for sol in self.solutions:
sol.pop(var.name, None)
del self.defined_vars[var.name]
def _var_index(self, var):
"""get variable index in the list using identity (Variable and VariableRef
define __cmp__
"""
for i, term in enumerate(self.selection):
if term is var:
return i
raise IndexError()
def remove_selected(self, var):
"""deletes var from selection variable"""
# assert isinstance(var, VariableRef)
index = self._var_index(var)
if self.should_register_op:
from rql.undo import UnselectVarOperation
self.undo_manager.add_operation(UnselectVarOperation(var, index))
for vref in self.selection.pop(index).iget_nodes(nodes.VariableRef):
vref.unregister_reference()
def add_selected(self, term, index=None):
"""override Select.add_selected to memoize modification when needed"""
if isinstance(term, nodes.Variable):
term = nodes.VariableRef(term, noautoref=1)
term.register_reference()
else:
for var in term.iget_nodes(nodes.VariableRef):
var = nodes.variable_ref(var)
var.register_reference()
if index is not None:
self.selection.insert(index, term)
term.parent = self
else:
self.append_selected(term)
if self.should_register_op:
from rql.undo import SelectVarOperation
self.undo_manager.add_operation(SelectVarOperation(term))
def add_group_var(self, var, index=None):
"""add var in 'orderby' constraints
asc is a boolean indicating the group order (ascendent or descendent)
"""
if not self.groupby:
self.groupby = []
vref = nodes.variable_ref(var)
vref.register_reference()
if index is None:
self.groupby.append(vref)
else:
self.groupby.insert(index, vref)
vref.parent = self
if self.should_register_op:
from rql.undo import AddGroupOperation
self.undo_manager.add_operation(AddGroupOperation(vref))
def remove_group_term(self, term):
"""remove the group variable and the group node if necessary"""
if self.should_register_op:
from rql.undo import RemoveGroupOperation
self.undo_manager.add_operation(RemoveGroupOperation(term))
for vref in term.iget_nodes(nodes.VariableRef):
vref.unregister_reference()
index = next(i for i, g in enumerate(self.groupby)
if term.is_equivalent(g))
del self.groupby[index]
remove_group_var = deprecated('[rql 0.29] use remove_group_term instead')(
remove_group_term)
def remove_groups(self):
for vref in self.groupby[:]:
self.remove_group_term(vref)
def add_sort_var(self, var, asc=True):
"""add var in 'orderby' constraints
asc is a boolean indicating the sort order (ascendent or descendent)
"""
vref = nodes.variable_ref(var)
vref.register_reference()
term = nodes.SortTerm(vref, asc)
self.add_sort_term(term)
def add_sort_term(self, term, index=None):
if not self.orderby:
self.orderby = []
if index is None:
self.orderby.append(term)
else:
self.orderby.insert(index, term)
term.parent = self
for vref in term.iget_nodes(nodes.VariableRef):
try:
vref.register_reference()
except AssertionError:
pass # already referenced
if self.should_register_op:
from rql.undo import AddSortOperation
self.undo_manager.add_operation(AddSortOperation(term))
def remove_sort_terms(self):
if self.orderby:
for term in self.orderby[:]:
self.remove_sort_term(term)
def remove_sort_term(self, term):
"""remove a sort term and the sort node if necessary"""
if self.should_register_op:
from rql.undo import RemoveSortOperation
self.undo_manager.add_operation(RemoveSortOperation(term))
for vref in term.iget_nodes(nodes.VariableRef):
vref.unregister_reference()
self.orderby.remove(term)
def select_only_variables(self):
selection = []
for term in self.selection:
for vref in term.iget_nodes(nodes.VariableRef):
if not any(vref.is_equivalent(s) for s in selection):
vref.parent = self
selection.append(vref)
self.selection = selection
import sys
import re
from os.path import exists, expanduser
from copy import copy
from ConfigParser import ConfigParser, NoOptionError, NoSectionError, \
DuplicateSectionError
from warnings import warn
from logilab.common.compat import set, reversed
from logilab.common.textutils import normalize_text, unquote
from logilab.common.deprecation import deprecated
from logilab.common import optik_ext as optparse
REQUIRED = []
check_csv = deprecated('use lgc.optik_ext.check_csv')(optparse.check_csv)
class UnsupportedAction(Exception):
"""raised by set_option when it doesn't know what to do for an action"""
def _get_encoding(encoding, stream):
encoding = encoding or getattr(stream, 'encoding', None)
if not encoding:
import locale
encoding = locale.getpreferredencoding()
return encoding
def _encode(string, encoding):
value = self.NO_DEFAULT_VALUE
return option.help.replace(self.default_tag, str(value))
def _validate(value, optdict, name=''):
"""return a validated value for an option according to its type
optional argument name is only used for error message formatting
"""
try:
_type = optdict['type']
except KeyError:
# FIXME
return value
return _call_validator(_type, optdict, name, value)
convert = deprecated('[0.60] convert() was renamed _validate()')(_validate)
# format and output functions ##################################################
def comment(string):
"""return string as a comment"""
lines = [line.strip() for line in string.splitlines()]
return '# ' + ('%s# ' % os.linesep).join(lines)
def format_time(value):
if not value:
return '0'
if value != int(value):
return '%.2fs' % value
value = int(value)
nbmin, nbsec = divmod(value, 60)
return sep.join(result)
def norm_read(path):
"""Return the content of the file with normalized line feeds.
:type path: str
:param path: path to the file to read
:rtype: str
:return: the content of the file with normalized line feeds
"""
return open(path, 'U').read()
norm_read = deprecated("use \"open(path, 'U').read()\"")(norm_read)
def norm_open(path):
"""Return a stream for a file with content with normalized line feeds.
:type path: str
:param path: path to the file to open
:rtype: file or StringIO
:return: the opened file with normalized line feeds
"""
return open(path, 'U')
norm_open = deprecated("use \"open(path, 'U')\"")(norm_open)
else:
from io import FileIO, BytesIO, StringIO
from imp import reload
# Where do pickles come from?
try:
import cPickle as pickle
except ImportError:
import pickle
from logilab.common.deprecation import deprecated
from itertools import izip, chain, imap
if sys.version_info < (3, 0): # 2to3 will remove the imports
izip = deprecated("izip exists in itertools since py2.3")(izip)
imap = deprecated("imap exists in itertools since py2.3")(imap)
chain = deprecated("chain exists in itertools since py2.3")(chain)
sum = deprecated("sum exists in builtins since py2.3")(sum)
enumerate = deprecated("enumerate exists in builtins since py2.3")(enumerate)
frozenset = deprecated("frozenset exists in builtins since py2.4")(frozenset)
reversed = deprecated("reversed exists in builtins since py2.4")(reversed)
sorted = deprecated("sorted exists in builtins since py2.4")(sorted)
max = deprecated("max exists in builtins since py2.4")(max)
# Python2.5 builtins
try:
any = any
all = all
>>> splitstrip('a')
['a']
>>>
:type string: str or unicode
:param string: a csv line
:type sep: str or unicode
:param sep: field separator, default to the comma (',')
:rtype: str or unicode
:return: the unquoted string (or the input string if it wasn't quoted)
"""
return [word.strip() for word in string.split(sep) if word.strip()]
get_csv = deprecated('get_csv is deprecated, use splitstrip')(splitstrip)
def split_url_or_path(url_or_path):
"""return the latest component of a string containing either an url of the
form <scheme>://<path> or a local file system path
"""
if '://' in url_or_path:
return url_or_path.rstrip('/').rsplit('/', 1)
return osp.split(url_or_path.rstrip(osp.sep))
def text_to_dict(text):
"""parse multilines text containing simple 'key=value' lines and return a
dict of {'key': 'value'}. When the same key is encountered multiple time,
value is turned into a list containing all values.
# See also http://bugs.python.org/issue11776
if sys.version_info[0] == 3:
def method_type(callable, instance, klass):
# api change. klass is no more considered
return types.MethodType(callable, instance)
else:
# alias types otherwise
method_type = types.MethodType
# Pythons 2 and 3 differ on where to get StringIO
if sys.version_info < (3, 0):
from cStringIO import StringIO
FileIO = file
BytesIO = StringIO
reload = reload
else:
from io import FileIO, BytesIO, StringIO
from imp import reload
from logilab.common.deprecation import deprecated
# Other projects import these from here, keep providing them for
# backwards compat
any = deprecated('use builtin "any"')(any)
all = deprecated('use builtin "all"')(all)
result.append('..')
result += to_parts
return sep.join(result)
def norm_read(path):
"""Return the content of the file with normalized line feeds.
:type path: str
:param path: path to the file to read
:rtype: str
:return: the content of the file with normalized line feeds
"""
return open(path, 'U').read()
norm_read = deprecated("use \"open(path, 'U').read()\"")(norm_read)
def norm_open(path):
"""Return a stream for a file with content with normalized line feeds.
:type path: str
:param path: path to the file to open
:rtype: file or StringIO
:return: the opened file with normalized line feeds
"""
return open(path, 'U')
norm_open = deprecated("use \"open(path, 'U')\"")(norm_open)
def lines(path, comments=None):
"""Return a list of non empty lines in the file located at `path`.
reload = reload
else:
from io import FileIO, BytesIO, StringIO
from imp import reload
# Where do pickles come from?
try:
import cPickle as pickle
except ImportError:
import pickle
from logilab.common.deprecation import deprecated
from itertools import izip, chain, imap
if sys.version_info < (3, 0):# 2to3 will remove the imports
izip = deprecated('izip exists in itertools since py2.3')(izip)
imap = deprecated('imap exists in itertools since py2.3')(imap)
chain = deprecated('chain exists in itertools since py2.3')(chain)
sum = deprecated('sum exists in builtins since py2.3')(sum)
enumerate = deprecated('enumerate exists in builtins since py2.3')(enumerate)
frozenset = deprecated('frozenset exists in builtins since py2.4')(frozenset)
reversed = deprecated('reversed exists in builtins since py2.4')(reversed)
sorted = deprecated('sorted exists in builtins since py2.4')(sorted)
max = deprecated('max exists in builtins since py2.4')(max)
# Python2.5 builtins
try:
any = any
all = all
else:
import unittest as unittest
from unittest import SkipTest
from functools import wraps
from logilab.common.debugger import Debugger
from logilab.common.decorators import cached, classproperty
from logilab.common import textutils
__all__ = ['unittest_main', 'find_tests', 'nocoverage', 'pause_trace']
DEFAULT_PREFIXES = ('test', 'regrtest', 'smoketest', 'unittest', 'func',
'validation')
is_generator = deprecated('[lgc 0.63] use inspect.isgeneratorfunction')(
isgeneratorfunction)
# used by unittest to count the number of relevant levels in the traceback
__unittest = 1
@deprecated('with_tempdir is deprecated, use {0}.TemporaryDirectory.'.format(
'tempfile' if not PY2 else 'backports.tempfile'))
def with_tempdir(callable):
"""A decorator ensuring no temporary file left when the function return
Work only for temporary file created with the tempfile module"""
if isgeneratorfunction(callable):
def proxy(*args, **kwargs):
old_tmpdir = tempfile.gettempdir()
new_tmpdir = tempfile.mkdtemp(prefix="temp-lgc-")
class OptionsProviderMixIn(object):
"""Mixin to provide options to an OptionsManager"""
# those attributes should be overridden
priority = -1
name = 'default'
options = ()
level = 0
def __init__(self):
self.config = optik_ext.Values()
for option in self.options:
try:
option, optdict = option
except ValueError:
raise Exception('Bad option: %r' % option)
if isinstance(optdict.get('default'), Method):
optdict['default'].bind(self)
elif isinstance(optdict.get('callback'), Method):
optdict['callback'].bind(self)
self.load_defaults()
def load_defaults(self):
"""initialize the provider using default values"""
for opt, optdict in self.options:
action = optdict.get('action')
if action != 'callback':
# callback action have no default
default = self.option_default(opt, optdict)
if default is REQUIRED:
continue
self.set_option(opt, default, action, optdict)
def option_default(self, opt, optdict=None):
"""return the default value for an option"""
if optdict is None:
optdict = self.get_option_def(opt)
default = optdict.get('default')
if callable(default):
default = default()
return default
def option_attrname(self, opt, optdict=None):
"""get the config attribute corresponding to opt
"""
if optdict is None:
optdict = self.get_option_def(opt)
return optdict.get('dest', opt.replace('-', '_'))
option_name = deprecated('[0.60] OptionsProviderMixIn.option_name() was renamed to option_attrname()')(option_attrname)
def option_value(self, opt):
"""get the current value for the given option"""
return getattr(self.config, self.option_attrname(opt), None)
def set_option(self, opt, value, action=None, optdict=None):
"""method called to set an option (registered in the options list)
"""
if optdict is None:
optdict = self.get_option_def(opt)
if value is not None:
value = _validate(value, optdict, opt)
if action is None:
action = optdict.get('action', 'store')
if optdict.get('type') == 'named': # XXX need specific handling
optname = self.option_attrname(opt, optdict)
currentvalue = getattr(self.config, optname, None)
if currentvalue:
currentvalue.update(value)
value = currentvalue
if action == 'store':
setattr(self.config, self.option_attrname(opt, optdict), value)
elif action in ('store_true', 'count'):
setattr(self.config, self.option_attrname(opt, optdict), 0)
elif action == 'store_false':
setattr(self.config, self.option_attrname(opt, optdict), 1)
elif action == 'append':
opt = self.option_attrname(opt, optdict)
_list = getattr(self.config, opt, None)
if _list is None:
if isinstance(value, (list, tuple)):
_list = value
elif value is not None:
_list = []
_list.append(value)
setattr(self.config, opt, _list)
elif isinstance(_list, tuple):
setattr(self.config, opt, _list + (value,))
else:
_list.append(value)
elif action == 'callback':
optdict['callback'](None, opt, value, None)
else:
raise UnsupportedAction(action)
def input_option(self, option, optdict, inputlevel=99):
default = self.option_default(option, optdict)
if default is REQUIRED:
defaultstr = '(required): '
elif optdict.get('level', 0) > inputlevel:
return
elif optdict['type'] == 'password' or default is None:
defaultstr = ': '
else:
defaultstr = '(default: %s): ' % format_option_value(optdict, default)
print ':%s:' % option
print optdict.get('help') or option
inputfunc = INPUT_FUNCTIONS[optdict['type']]
value = inputfunc(optdict, defaultstr)
while default is REQUIRED and not value:
print 'please specify a value'
value = inputfunc(optdict, '%s: ' % option)
if value is None and default is not None:
value = default
self.set_option(option, value, optdict=optdict)
def get_option_def(self, opt):
"""return the dictionary defining an option given it's name"""
assert self.options
for option in self.options:
if option[0] == opt:
return option[1]
raise OptionError('no such option %s in section %r'
% (opt, self.name), opt)
def all_options(self):
"""return an iterator on available options for this provider
option are actually described by a 3-uple:
(section, option name, option dictionary)
"""
for section, options in self.options_by_section():
if section is None:
if self.name is None:
continue
section = self.name.upper()
for option, optiondict, value in options:
yield section, option, optiondict
def options_by_section(self):
"""return an iterator on options grouped by section
(section, [list of (optname, optdict, optvalue)])
"""
sections = {}
for optname, optdict in self.options:
sections.setdefault(optdict.get('group'), []).append(
(optname, optdict, self.option_value(optname)))
if None in sections:
yield None, sections.pop(None)
for section, options in sections.items():
yield section.upper(), options
def options_and_values(self, options=None):
if options is None:
options = self.options
for optname, optdict in options:
yield (optname, optdict, self.option_value(optname))
value = self.NO_DEFAULT_VALUE
return option.help.replace(self.default_tag, str(value))
def _validate(value, optdict, name=''):
"""return a validated value for an option according to its type
optional argument name is only used for error message formatting
"""
try:
_type = optdict['type']
except KeyError:
# FIXME
return value
return _call_validator(_type, optdict, name, value)
convert = deprecated('[0.60] convert() was renamed _validate()')(_validate)
# format and output functions ##################################################
def comment(string):
"""return string as a comment"""
lines = [line.strip() for line in string.splitlines()]
return '# ' + ('%s# ' % os.linesep).join(lines)
def format_time(value):
if not value:
return '0'
if value != int(value):
return '%.2fs' % value
value = int(value)
nbmin, nbsec = divmod(value, 60)
['a']
>>>
:type string: str or unicode
:param string: a csv line
:type sep: str or unicode
:param sep: field separator, default to the comma (',')
:rtype: str or unicode
:return: the unquoted string (or the input string if it wasn't quoted)
"""
return [word.strip() for word in string.split(sep) if word.strip()]
get_csv = deprecated()(splitstrip)
def split_url_or_path(url_or_path):
"""return the latest component of a string containing either an url of the
form <scheme>://<path> or a local file system path
"""
if '://' in url_or_path:
return url_or_path.rstrip('/').rsplit('/', 1)
return osp.split(url_or_path.rstrip(osp.sep))
def text_to_dict(text):
"""parse multilines text containing simple 'key=value' lines and return a
dict of {'key': 'value'}. When the same key is encountered multiple time,
value is turned into a list containing all values.
outfile = open(join(destdir, name), 'wb')
outfile.write(zfobj.read(name))
outfile.close()
class Execute:
"""This is a deadlock safe version of popen2 (no stdin), that returns
an object with errorlevel, out and err.
"""
def __init__(self, command):
cmd = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
self.out, self.err = cmd.communicate()
self.status = os.WEXITSTATUS(cmd.returncode)
Execute = deprecated('Use subprocess.Popen instead')(Execute)
class ProgressBar(object):
"""A simple text progression bar."""
def __init__(self, nbops, size=20, stream=sys.stdout, title=''):
if title:
self._fstr = '\r%s [%%-%ss]' % (title, int(size))
else:
self._fstr = '\r[%%-%ss]' % int(size)
self._stream = stream
self._total = nbops
self._size = size
self._current = 0
self._progress = 0
class Execute:
"""This is a deadlock safe version of popen2 (no stdin), that returns
an object with errorlevel, out and err.
"""
def __init__(self, command):
cmd = subprocess.Popen(command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
self.out, self.err = cmd.communicate()
self.status = os.WEXITSTATUS(cmd.returncode)
Execute = deprecated('Use subprocess.Popen instead')(Execute)
def acquire_lock(lock_file, max_try=10, delay=10, max_delay=3600):
"""Acquire a lock represented by a file on the file system
If the process written in lock file doesn't exist anymore, we remove the
lock file immediately
If age of the lock_file is greater than max_delay, then we raise a UserWarning
"""
count = abs(max_try)
while count:
try:
fd = os.open(lock_file, os.O_EXCL | os.O_RDWR | os.O_CREAT)
os.write(fd, str_to_bytes(str(os.getpid())))
os.close(fd)
import sys
import re
from os.path import exists, expanduser
from copy import copy
from ConfigParser import ConfigParser, NoOptionError, NoSectionError, \
DuplicateSectionError
from warnings import warn
from logilab.common.compat import set, reversed
from logilab.common.textutils import normalize_text, unquote
from logilab.common.deprecation import deprecated
from logilab.common import optik_ext as optparse
REQUIRED = []
check_csv = deprecated('use lgc.optik_ext.check_csv')(optparse.check_csv)
class UnsupportedAction(Exception):
"""raised by set_option when it doesn't know what to do for an action"""
def _get_encoding(encoding, stream):
encoding = encoding or getattr(stream, 'encoding', None)
if not encoding:
import locale
encoding = locale.getpreferredencoding()
return encoding
def _encode(string, encoding):
if isinstance(string, unicode):
return string.encode(encoding)
import unittest
from unittest import SkipTest
from functools import wraps
from logilab.common.debugger import Debugger, colorize_source
from logilab.common.decorators import cached, classproperty
from logilab.common import textutils
__all__ = ['main', 'unittest_main', 'find_tests', 'run_test', 'spawn']
DEFAULT_PREFIXES = ('test', 'regrtest', 'smoketest', 'unittest',
'func', 'validation')
is_generator = deprecated('[lgc 0.63] use inspect.isgeneratorfunction')(isgeneratorfunction)
# used by unittest to count the number of relevant levels in the traceback
__unittest = 1
def with_tempdir(callable):
"""A decorator ensuring no temporary file left when the function return
Work only for temporary file created with the tempfile module"""
if isgeneratorfunction(callable):
def proxy(*args, **kwargs):
old_tmpdir = tempfile.gettempdir()
new_tmpdir = tempfile.mkdtemp(prefix="temp-lgc-")
tempfile.tempdir = new_tmpdir
try:
for x in callable(*args, **kwargs):
('remove_from_addmenu', uicfg.actionbox_appearsin_addmenu),
('set_fields_order', uicfg.autoform_field_kwargs),
('hide_field', uicfg.autoform_section),
('hide_fields', uicfg.autoform_section),
('set_field_kwargs', uicfg.autoform_field_kwargs),
('set_field', uicfg.autoform_field),
('edit_inline', uicfg.autoform_section),
('edit_as_attr', uicfg.autoform_section),
('set_muledit_editable', uicfg.autoform_section),
)
for funcname, tag in backward_compat_funcs:
msg = ('[3.16] uihelper.%(name)s is deprecated, please use '
'web.views.uicfg.%(rtagid)s.%(name)s' %
dict(name=funcname, rtagid=tag.__regid__))
globals()[funcname] = deprecated(msg)(getattr(tag, funcname))
class meta_formconfig(type):
"""metaclass of FormConfig classes, only for easier declaration purpose"""
def __init__(cls, name, bases, classdict):
if cls.etype is None:
return
uicfg_afs = cls.uicfg_afs or uicfg.autoform_section
uicfg_aff = cls.uicfg_aff or uicfg.autoform_field
uicfg_affk = cls.uicfg_affk or uicfg.autoform_field_kwargs
for attr_role in cls.hidden:
uicfg_afs.hide_field(cls.etype, attr_role, formtype=cls.formtype)
for attr_role in cls.rels_as_attrs:
uicfg_afs.edit_as_attr(cls.etype, attr_role, formtype=cls.formtype)
for attr_role in cls.inlined:
>>> splitstrip('a')
['a']
>>>
:type string: str or unicode
:param string: a csv line
:type sep: str or unicode
:param sep: field separator, default to the comma (',')
:rtype: str or unicode
:return: the unquoted string (or the input string if it wasn't quoted)
"""
return [word.strip() for word in string.split(sep) if word.strip()]
get_csv = deprecated()(splitstrip)
def split_url_or_path(url_or_path):
"""return the latest component of a string containing either an url of the
form <scheme>://<path> or a local file system path
"""
if '://' in url_or_path:
return url_or_path.rstrip('/').rsplit('/', 1)
return osp.split(url_or_path.rstrip(osp.sep))
def text_to_dict(text):
"""parse multilines text containing simple 'key=value' lines and return a
dict of {'key': 'value'}. When the same key is encountered multiple time,
value is turned into a list containing all values.
def test_deprecated_func(self):
any_func = deprecation.deprecated()(self.mk_func())
any_func()
any_func = deprecation.deprecated('message')(self.mk_func())
any_func()
def test_deprecated_func(self):
any_func = deprecation.deprecated()(self.mk_func())
any_func()
any_func = deprecation.deprecated('message')(self.mk_func())
any_func()
reload = reload
else:
from io import FileIO, BytesIO, StringIO
from imp import reload
# Where do pickles come from?
try:
import cPickle as pickle
except ImportError:
import pickle
from logilab.common.deprecation import deprecated
from itertools import izip, chain, imap
if sys.version_info < (3, 0):# 2to3 will remove the imports
izip = deprecated('izip exists in itertools since py2.3')(izip)
imap = deprecated('imap exists in itertools since py2.3')(imap)
chain = deprecated('chain exists in itertools since py2.3')(chain)
sum = deprecated('sum exists in builtins since py2.3')(sum)
enumerate = deprecated('enumerate exists in builtins since py2.3')(enumerate)
frozenset = deprecated('frozenset exists in builtins since py2.4')(frozenset)
reversed = deprecated('reversed exists in builtins since py2.4')(reversed)
sorted = deprecated('sorted exists in builtins since py2.4')(sorted)
max = deprecated('max exists in builtins since py2.4')(max)
# Python2.5 builtins
try:
any = any
all = all
# Where do pickles come from?
try:
import cPickle as pickle
except ImportError:
import pickle
try:
set = set
frozenset = frozenset
except NameError:# Python 2.3 doesn't have `set`
from sets import Set as set, ImmutableSet as frozenset
from logilab.common.deprecation import deprecated
from itertools import izip, chain, imap
izip = deprecated('izip exists in itertools since py2.3')(izip)
imap = deprecated('imap exists in itertools since py2.3')(imap)
chain = deprecated('chain exists in itertools since py2.3')(chain)
sum = deprecated('sum exists in builtins since py2.3')(sum)
enumerate = deprecated('enumerate exists in builtins since py2.3')(enumerate)
try:
sorted = sorted
reversed = reversed
except NameError: # py2.3
def sorted(iterable, cmp=None, key=None, reverse=False):
original = list(iterable)
if key:
l2 = [(key(elt), index) for index, elt in builtins.enumerate(original)]
