Module contract

Modify a class to add invariant checking.

   isstring(code[0])
   type(code[1]) == code[2]
   isinstance(code[0], MethodType) or isinstance(code[0], FunctionType)
   isinstance(path[0], ModuleType)
   forall(path[1:], isclass)

Get function location as tuple (name, filename, lineno).

   isinstance(f, MethodType) or isinstance(f, FunctionType)

   isstring(__return__[0])
   isstring(__return__[1])
   isinstance(__return__[2], int)

Returns two lists (procs, types) where each list contains (name, value) tuples.

For classes, only attributes defined by the specific class are returned, i.e. not inherited attributes. Attributes created by this module (prefixed by '__assert_') are skipped as well.

Examples: >>> import contract >>> path = [contract] >>> hasattr(contract, '_re_start') 1 >>> '_re_start' in [x[0] for x in _get_members(contract, path)[0]] 0 >>> '_get_members' in [x[0] for x in _get_members(contract, path)[0]] 1 >>> 'checkmod' in [x[0] for x in _get_members(contract, path)[0]] 1 >>> class base: ... def foo(self): pass >>> class derived(base): ... def bar(self): pass

hasattr can get inherited attributes: >>> hasattr(derived, 'foo') 1

Checks if a name is public (starts and ends with '__' or doesn't start with a _ at all).

Read an indented block of expressions

startlineno is *zero* origined line number.

   input.readline  # must have readline function

Examples: #>>> _read_block(StringIO('\tfoo:\n'), 0) #0 >>> _read_block(StringIO('\tpost[]: True\n'), 0) ('post', [], [('True', 1)], 1) >>> _read_block(StringIO('\tpre: 5 + 6 > 10\n'), 0) ('pre', [], [('5 + 6 > 10', 1)], 1) >>> _read_block(StringIO('\tpost:\n\t\t5 + 6 < 12\n\t\t2 + 2 == 4\n'), 0) ('post', [], [('5 + 6 < 12', 2), ('2 + 2 == 4', 3)], 3) >>> _read_block(StringIO('\tpost[foo.bar]: # changes\n' \ ... '\t\tlen(foo.bar) > 0\n'), 0) ('post', [['foo', 'bar']], [('len ( foo . bar ) > 0', 2)], 2)

Creates and installs a function/method checker.

   contracts[0][0] == PRE and contracts[1][0] == POST
   isinstance(path[0], ModuleType)
   forall(path[1:], isclass)

Define a function that does contract assertion checking.

args is a string argument declaration (ex: 'a, b, c = 1, *va, **ka') contract is an element of the contracts list returned by parse_docstring module is the containing module (not parent class)

Returns the newly-defined function.

   isstring(name)
   isstring(args)
   contract[0] in _CONTRACTS
   len(contract[2]) > 0

   isinstance(__return__, FunctionType)
   __return__.__name__ == name

Create a function that saves values into an __old__ variable.

Formats an argument desc into a string suitable for both a function/ method declaration or a function call.

This does *not* handle default arguments. Default arguments are already evaluated... use new.function() to create a function with pre-evaluated default arguments.

Examples: >>> def foo(a, (b, c), d = 1, e = 2, *va, **ka): ... pass >>> a = getargspec(foo) >>> a (['a', '(b, c)', 'd', 'e'], 'va', 'ka', (1, 2)) >>> _format_args(a) 'a, (b, c), d, e, *va, **ka'

   isinstance(arguments, list)
   rest is None or isstring(rest)
   keywords is None or isstring(keywords)

>>> _format_arg(['a', 'b', 'c'])
'(a, b, c)'
>>> _format_arg(['a', ['b', 'c', 'd']])
'(a, (b, c, d))'
>>> _format_arg(['a'])
'(a,)'
>>> _format_arg('a')
'a'

Define a name combining a path and arbitrary strings.

  isinstance(path[0], ModuleType)
  forall(path[1:], isclass)

Recursively output a dictionary into a set of 'old' assignments.

The dictionary d is a tree of variable declarations.  So, for example,
the declaration [self, self.buf, self.obj.a] would turn into the dict
{'self': {'buf': {}, 'obj': {'a': {}}}}, and would get output as
    __old__.self = contract._holder()
    __old__.self.buf = copy.copy(self.buf)
    __old__.self.obj = contract._holder()
    __old__.self.obj.a = copy.copy(self.obj.a)

Converts a list of list of names into a hierarchy of dictionaries.

Checks class invariants on an instance.

mro - list of classes in method-resolution order instance - object to test

   # instance must be an instance of each class in mro
   forall(mro, lambda x: isinstance(instance, x))

Check the invocation of a method.

Check the invocation of a method.

Test if a class has a named method.

   isclass(cls)
   isstring(name)

_EXCEPTIONS

Value:

{'inv': 'InvariantViolationError', 'post': 'PostconditionViolationError', 'pre': 'PreconditionViolationError'}