Application: gvSIG desktop » gvSIG scripting

from data.module import YO, YOUPI

import data

class Specialization(YOUPI, YO):

    pass

class Metaclass(type):

    pass

class Interface:

    pass

class MyIFace(Interface):

    pass

class AnotherIFace(Interface):

    pass

class MyException(Exception):

    pass

class MyError(MyException):

    pass

class AbstractClass(object):

    def to_override(self, whatever):

        raise NotImplementedError()

    def return_something(self, param):

        if param:

            return 'toto'

        return

class Concrete0:

    __implements__ = MyIFace

class Concrete1:

    __implements__ = (MyIFace, AnotherIFace)

class Concrete2:

    __implements__ = (MyIFace, AnotherIFace)

class Concrete23(Concrete1):

    pass

del YO.member

del YO

[SYN1, SYN2] = (Concrete0, Concrete1)

assert '1'

b = (1) | (((2) & (3)) ^ (8))

bb = ((1) | (two)) | (6)

ccc = ((one) & (two)) & (three)

dddd = ((x) ^ (o)) ^ (r)

exec 'c = 3'

exec 'c = 3' in {}, {}

def raise_string(a=2, *args, **kwargs):

    raise Exception, 'yo'

    yield 'coucou'

    yield

a = (b) + (2)

c = (b) * (2)

c = (b) / (2)

c = (b) // (2)

c = (b) - (2)

c = (b) % (2)

c = (b) ** (2)

c = (b) << (2)

c = (b) >> (2)

c = ~b

c = not b

d = [c]

e = d[:]

e = d[a:b:c]

raise_string(*args, **kwargs)

print >> stream, 'bonjour'

print >> stream, 'salut',

def make_class(any, base=data.module.YO, *args, **kwargs):

    """check base is correctly resolved to Concrete0"""

    class Aaaa(base):

        """dynamic class"""

    return Aaaa

from os.path import abspath

import os as myos

class A:

    pass

class A(A):

    pass

def generator():

    """A generator."""

    yield

def not_a_generator():

    """A function that contains generator, but is not one."""

    def generator():

        yield

    genl = lambda : (yield)

def with_metaclass(meta, *bases):

    return meta('NewBase', bases, {})

class NotMetaclass(with_metaclass(Metaclass)):

    pass