コード例 #1
0
ファイル: _meta3.py プロジェクト: edelvalle/xoutil
def metaclass(meta, **kwargs):
    class base:
        pass

    metabase = meta.__base__
    if metabase is object:  # when meta is type
        metabase = type

    class inner_meta(metabase):
        @classmethod
        def __prepare__(cls, name, bases, **kwargs):
            prepare = getattr(meta, '__prepare__', None)
            if prepare:
                return prepare(name, bases, **kwargs)
            else:
                return dict()

        def __new__(cls, name, bases, attrs, **kw):
            if name != '__inner__':
                bases = tuple(b for b in bases if not issubclass(b, base))
                if not bases:
                    bases = (object,)
                return meta(name, bases, attrs)
            else:
                return type.__new__(cls, name, bases, attrs)

        def __init__(self, name, bases, attrs, **kw):
            pass

    from xoutil.types import new_class
    kwds = dict(kwargs, metaclass=inner_meta)
    return new_class('__inner__', (base, ), kwds=kwds)
コード例 #2
0
ファイル: _meta2.py プロジェクト: edelvalle/xoutil
def metaclass(meta, **kwargs):
    prepare = getattr(meta, '__prepare__', None)
    if prepare:
        import warnings
        warnings.warn('Python 2.7 does not have the __prepare__ stuff and '
                      'the metaclass "%s" seems to needs it.' % meta,
                      stacklevel=2)

    class base(object):
        pass

    metabase = meta.__base__
    if metabase is object:  # when meta is type
        metabase = type

    class inner_meta(metabase):
        def __new__(cls, name, bases, attrs):
            from copy import copy
            if name != '__inner__':
                bases = tuple(b for b in bases if not issubclass(b, base))
                if not bases:
                    bases = (object,)
                from xoutil.types import prepare_class
                kwds = dict(kwargs, metaclass=meta)
                basemeta, _ns, kwds = prepare_class(name, bases, kwds=kwds)
                ns = copy(_ns)
                update = getattr(ns, 'update', None)
                if update:
                    update(attrs)
                else:
                    for attr, val in attrs.items():
                        ns[attr] = val
                if METACLASS_ATTR not in attrs:
                    attrs[METACLASS_ATTR] = meta
                return basemeta(name, bases, ns)
            else:
                return type.__new__(cls, name, bases, attrs)

    from xoutil.types import new_class
    kwds = dict(kwargs, metaclass=inner_meta)

    def exec_body(ns):
        return ns

    return new_class(str('__inner__'), (base, ), kwds=kwds,
                     exec_body=exec_body)
コード例 #3
0
__all__ = []
_nodes = [pyast.Expression, pyast.expr, pyast.boolop, pyast.unaryop,
          pyast.keyword, pyast.slice, pyast.operator, pyast.cmpop,
          pyast.comprehension, pyast.arguments, pyast.expr_context]
from xoutil.eight import _py3
if _py3:
    _nodes.append(pyast.arg)
_current = 0

while _current < len(_nodes):
    _node = _nodes[_current]
    _more = _node.__subclasses__()  # Don't place this after the new class.

    globals()['_PyAst_%s' % _node.__name__] = _node
    # Has a constructor create the class for comparing
    globals()[_node.__name__] = new_class(_node.__name__,
                                          bases=(PyASTNode, _node))
    __all__.append(_node.__name__)

    if _more:
        _nodes.extend(_more)
    _current += 1


# This None as a name.  Only use this for comparison, not as a return value.
LOAD_NONE = Name('None', Load())   # noqa
if _py_version >= (3, 4):
    NONE_CT = NameConstant(None)        # noqa
else:
    NONE_CT = None

    # Declares the NameConstant object with an impossible value so that tests