예제 #1
0
 def _settle_cache(target, source, recursed=None):
     '''`target` is a mapping to store result commands'''
     if recursed is None:
         recursed = set()
     # TODO: Convert check based in argument "recursed" in a decorator
     from xoutil.names import nameof
     name = nameof(source, inner=True, full=True)
     if name not in recursed:
         recursed.add(name)
         sub_commands = type.__subclasses__(source)
         sub_commands.extend(getattr(source, '_abc_registry', ()))
         cmds = getattr(source, '__commands__', None)
         if cmds:
             from collections import Iterable
             if not isinstance(cmds, Iterable):
                 cmds = cmds()
             sub_commands.extend(cmds)
         if sub_commands:
             for cmd in sub_commands:
                 Command._settle_cache(target, cmd, recursed=recursed)
         else:   # Only branch commands are OK to execute
             from types import MethodType
             assert isinstance(source.run, MethodType)
             target[command_name(source)] = source
     else:
         raise ValueError('Reused class "%s"!' % name)
예제 #2
0
 def __repr__(self):
     from xoutil.names import nameof
     name = getattr(self, 'name', None)
     if name:
         return str("<%s '%s'>" % (nameof(type(self), inner=True, full=True), name.encode('ascii', 'replace')))
     else:
         return super(Entity, self).__repr__()
예제 #3
0
 def __repr__(self):
     from xoutil.names import nameof
     name = getattr(self, 'name', None)
     if name:
         return str("<%s '%s'>" % (
             nameof(type(self), inner=True, full=True),
             safe_encode(name)))
     else:
         return super().__repr__()
예제 #4
0
파일: bound.py 프로젝트: olemis/xoutil
 def __new__(cls, definition, name=None):
     from types import FunctionType
     if not isinstance(definition, FunctionType):
         raise TypeError('"definition" must be a function')
     if not name:
         from xoutil.names import nameof
         name = nameof(definition, inner=True, full=True)
     result = super(BoundaryCondition, cls).__new__(cls)
     result.name = name  # needs to be set here or it'll be None
     return result
예제 #5
0
        def _handle_fingerprint(self, record):
            from xoutil.names import nameof

            exc_info = record.exc_info
            if exc_info:
                _type, value, _tb = exc_info
                exc = nameof(_type, inner=True, full=True)
                if exc.startswith("psycopg2."):
                    fingerprint = [exc]
                else:
                    fingerprint = getattr(value, "_sentry_fingerprint", None)
                if fingerprint:
                    if not isinstance(fingerprint, list):
                        fingerprint = [fingerprint]
                    record.fingerprint = fingerprint
예제 #6
0
def get_object_module(obj, typed=False):
    """Return the name of the OpenERP addon the `obj` has been defined.

    If the `obj` is not defined (imported) from the "openerp.addons."
    namespace, return None.

    """
    from xoutil.names import nameof

    name = nameof(obj, inner=True, full=True, typed=typed)
    match = _ADDONS_NAMESPACE.match(name)
    if match:
        module = match.groupdict()["module"]
        return module
    else:
        return None
예제 #7
0
파일: objects.py 프로젝트: olemis/xoutil
 def __parse_arguments(self, *args, **kwargs):
     '''Assign parsed arguments to the just created instance.'''
     from xoutil.validators import (is_valid_identifier, predicate)
     self.attr_name = Unset
     self.init = Unset
     self.default = Unset
     self.do_assigning = True
     self.validator = True
     for i, arg in enumerate(args):
         if self.attr_name is Unset and is_valid_identifier(arg):
             self.attr_name = arg
         elif self.init is Unset and callable(arg):
             self.init = arg
         else:
             msg = ('Invalid positional arguments: %s at %s\n'
                    'Valid arguments are the attribute name and a '
                    'callable constructor for initial value.')
             raise ValueError(msg % (args[i:], i))
     bads = {}
     for key in kwargs:
         value = kwargs[key]
         if (self.default is Unset and self.init is Unset and
                 key in ('default', 'value', 'initial_value')):
             self.default = value
         elif (self.validator is True and
               key in ('validator', 'checker', 'check')):
             self.validator = value
         elif (self.do_assigning is True and key == 'do_assigning' and
               value is False):
             self.do_assigning = False
         else:
             bads[key] = value
     self.validator = predicate(self.validator)
     if bads:
         msg = ('Invalid keyword arguments: %s\n'
                'See constructor documentation for more info.')
         raise ValueError(msg % bads)
     if self.attr_name is Unset:
         from xoutil.names import nameof
         if self.init is not Unset:
             if isinstance(self.init, type):
                 self.attr_name = str('_%s' % self.init.__name__)
             else:
                 self.attr_name = nameof(self.init, safe=True)
         else:
             self.attr_name = self._unique_name()
     self.inner_name = str('__%s__' % self.attr_name.strip('_'))
예제 #8
0
def unstable(target, msg=None):
    '''Declares that a method, class or interface is unstable.

    This has the side-effect of issuing a warning the first time the `target`
    is invoked.

    The `msg` parameter, if given, should be string that contains, at most,
    two positional replacement fields ({0} and {1}). The first replacement
    field will be the type of `target` (interface, class or function) and the
    second matches `target's` full name.

    '''
    import warnings
    from xoutil.names import nameof
    from xoutil.eight import class_types
    if msg is None:
        msg = ('The {0} `{1}` is declared unstable. '
               'It may change in the future or be removed.')
    try:
        from zope.interface import Interface
    except ImportError:
        from xoutil import Ignored as Interface
    if isinstance(target, type(Interface)):
        objtype = 'interface'
    elif isinstance(target, class_types):
        objtype = 'class'
    else:
        objtype = 'function or method'
    message = msg.format(objtype,
                         nameof(target, inner=True, full=True))
    if isinstance(target, class_types) or issubclass(type(target),
                                                     type(Interface)):
        class meta(type(target)):
            pass

        def new(*args, **kwargs):
            warnings.warn(message, stacklevel=2)
            return target.__new__(*args, **kwargs)
        klass = meta(target.__name__, (target,), {'__new__': new})
        return klass
    else:
        def _unstable(*args, **kwargs):
            message = msg.format(objtype,
                                 nameof(target, inner=True, full=True))
            warnings.warn(message, stacklevel=2)
            return target(*args, **kwargs)
        return _unstable
예제 #9
0
def add_symbols_to_xmls(*objs, **symbols):
    """Allow to use the provided symbols in XMLs.

    Technically this replaces the function `safe_eval` in module
    `odoo.tools.convert` to include the symbols in the context.

    We keep a global dict of symbols, and only replace the `safe_eval`
    function once and update the global dict

    :param objs: Objects to be made available under its `proper name
                 <xoutil.names.nameof>`:func:.

    :param symbols: Objects to be made available under the keyword argument.

    .. versionadded:: 0.42.0

    .. versionchanged:: 0.43.0 Added the `objs` variable positional arguments.

    """
    if objs:
        symbols.update({nameof(obj, inner=True, full=False): obj for obj in objs})
    _SAFE_EVAL_SYMBOLS.update(symbols)
예제 #10
0
    def __init__(self, name, bases, attrs):
        from xoutil.names import nameof
        from xoutil.functools import compose
        OperatorType.operators.append(self)
        _PROVIDES = ('    This {which} directly provides '
                     ':class:`xotl.ql.interfaces.{interface}`.\n\n')
        doc = ''
        for attr, trans in (('arity', lambda x: nameof(x, inner=True)),
                            ('_method_name', repr),
                            ('_format', compose(str, repr))):
            value = getattr(self, attr, None)
            if value:
                v = trans(value).replace('_', r'\_')
                v = v.replace("'", '"')
                doc += ('\n\n    - **{attr}:** {v}'.format(attr=attr,
                                                           v=v))
        if doc:
            self.__doc__ = ((self.__doc__ if self.__doc__ else '') +
                            '\n\n    **Attributes**:' + doc)
        doc = ''
        interfaces = (IOperator, )
        if getattr(self, '_rmethod_name', False):
            interfaces += (ISyntacticallyReversibleOperation, )
            if 'ISyntacticallyReversibleOperation' not in self.__doc__:
                doc += _PROVIDES.format(
                            which='class',
                            interface='ISyntacticallyReversibleOperation')
        if getattr(self, 'equivalence_test', False):
            interfaces += (ISynctacticallyCommutativeOperation, )
            if 'ISynctacticallyCommutativeOperation' not in self.__doc__:
                doc += _PROVIDES.format(
                            which='class',
                            interface='ISynctacticallyCommutativeOperation')
        if doc:
            self.__doc__ += '\n\n    **Interface(s)**:\n\n' + doc

        directlyProvides(self, *interfaces)
예제 #11
0
 def __init__(self, validator, error):
     self.validator = validator
     self.validator_name = nameof(validator, inner=True)
     self.error = error or "This value is incorrect"
예제 #12
0
 def use_name(self):
     return nameof(self.use, inner=True)
예제 #13
0
 def __init__(self, type):
     self.type = type
     self.type_name = nameof(self.type, inner=True)
예제 #14
0
 def _unstable(*args, **kwargs):
     message = msg.format(objtype,
                          nameof(target, inner=True, full=True))
     warnings.warn(message, stacklevel=2)
     return target(*args, **kwargs)
예제 #15
0
    def __call__(self, func):
        from xoutil.names import nameof

        name = nameof(func, inner=True, full=False)
        self._registry[name] = func
        return func
예제 #16
0
    def __hash__(self):
        from xoutil.names import nameof

        return hash(nameof(self, inner=True, full=True))