Commits

Maciej Fijalkowski  committed 584c219

Remove the demo directory. It's not used (and not everything works there)

  • Participants
  • Parent commits 4bf9cf2

Comments (0)

Files changed (14)

File demo/autopath.py

-import sys, os
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

File demo/bpnn.py

-#!/usr/bin/env python
-"""
-    Translator Demo
-
-    To analyse and type-annotate the functions and class defined in
-    this module, starting from the entry point function demo(),
-    use the following command line:
-
-        ../pypy/translator/goal/translate.py bpnn.py
-
-    Insert '--help' before 'bpnn.py' for a list of translation options,
-    or see the Overview of Command Line Options for translation at
-    http://codespeak.net/pypy/dist/pypy/doc/config/commandline.html
-"""
-# Back-Propagation Neural Networks
-# 
-# Written in Python.  See http://www.python.org/
-#
-# Neil Schemenauer <nascheme@enme.ucalgary.ca>
-#
-# Modifications to the original (Armin Rigo):
-#   * import random from PyPy's lib, which is Python 2.2's plain
-#     Python implementation
-#   * print a doc about how to start the Translator
-
-import sys
-import math
-import time
-
-import autopath
-from pypy.rlib import rrandom
-
-PRINT_IT = True
-
-random = rrandom.Random(1)
-
-# calculate a random number where:  a <= rand < b
-def rand(a, b):
-    return (b-a)*random.random() + a
-
-# Make a matrix (we could use NumPy to speed this up)
-def makeMatrix(I, J, fill=0.0):
-    m = []
-    for i in range(I):
-        m.append([fill]*J)
-    return m
-
-class NN:
-    
-    def __init__(self, ni, nh, no):
-        # number of input, hidden, and output nodes
-        self.ni = ni + 1 # +1 for bias node
-        self.nh = nh
-        self.no = no
-
-        # activations for nodes
-        self.ai = [1.0]*self.ni
-        self.ah = [1.0]*self.nh
-        self.ao = [1.0]*self.no
-        
-        # create weights
-        self.wi = makeMatrix(self.ni, self.nh)
-        self.wo = makeMatrix(self.nh, self.no)
-        # set them to random vaules
-        for i in range(self.ni):
-            for j in range(self.nh):
-                self.wi[i][j] = rand(-2.0, 2.0)
-        for j in range(self.nh):
-            for k in range(self.no):
-                self.wo[j][k] = rand(-2.0, 2.0)
-
-        # last change in weights for momentum   
-        self.ci = makeMatrix(self.ni, self.nh)
-        self.co = makeMatrix(self.nh, self.no)
-
-    def update(self, inputs):
-        if len(inputs) != self.ni-1:
-            raise ValueError, 'wrong number of inputs'
-
-        # input activations
-        for i in range(self.ni-1):
-            #self.ai[i] = 1.0/(1.0+math.exp(-inputs[i]))
-            self.ai[i] = inputs[i]
-
-        # hidden activations
-        for j in range(self.nh):
-            sum = 0.0
-            for i in range(self.ni):
-                sum = sum + self.ai[i] * self.wi[i][j]
-            self.ah[j] = 1.0/(1.0+math.exp(-sum))
-
-        # output activations
-        for k in range(self.no):
-            sum = 0.0
-            for j in range(self.nh):
-                sum = sum + self.ah[j] * self.wo[j][k]
-            self.ao[k] = 1.0/(1.0+math.exp(-sum))
-
-        return self.ao[:]
-
-
-    def backPropagate(self, targets, N, M):
-        if len(targets) != self.no:
-            raise ValueError, 'wrong number of target values'
-
-        # calculate error terms for output
-        output_deltas = [0.0] * self.no
-        for k in range(self.no):
-            ao = self.ao[k]
-            output_deltas[k] = ao*(1-ao)*(targets[k]-ao)
-
-        # calculate error terms for hidden
-        hidden_deltas = [0.0] * self.nh
-        for j in range(self.nh):
-            sum = 0.0
-            for k in range(self.no):
-                sum = sum + output_deltas[k]*self.wo[j][k]
-            hidden_deltas[j] = self.ah[j]*(1-self.ah[j])*sum
-
-        # update output weights
-        for j in range(self.nh):
-            for k in range(self.no):
-                change = output_deltas[k]*self.ah[j]
-                self.wo[j][k] = self.wo[j][k] + N*change + M*self.co[j][k]
-                self.co[j][k] = change
-                #print N*change, M*self.co[j][k]
-
-        # update input weights
-        for i in range(self.ni):
-            for j in range(self.nh):
-                change = hidden_deltas[j]*self.ai[i]
-                self.wi[i][j] = self.wi[i][j] + N*change + M*self.ci[i][j]
-                self.ci[i][j] = change
-
-        # calculate error
-        error = 0.0
-        for k in range(len(targets)):
-            delta = targets[k]-self.ao[k]
-            error = error + 0.5*delta*delta
-        return error
-
-
-    def test(self, patterns):
-        for p in patterns:
-            if PRINT_IT:
-                print p[0], '->', self.update(p[0])
-
-    def weights(self):
-        if PRINT_IT:
-            print 'Input weights:'
-            for i in range(self.ni):
-                print self.wi[i]
-            print
-            print 'Output weights:'
-            for j in range(self.nh):
-                print self.wo[j]
-
-    def train(self, patterns, iterations=2000, N=0.5, M=0.1):
-        # N: learning rate
-        # M: momentum factor
-        for i in xrange(iterations):
-            error = 0.0
-            for p in patterns:
-                inputs = p[0]
-                targets = p[1]
-                self.update(inputs)
-                error = error + self.backPropagate(targets, N, M)
-            if PRINT_IT and i % 100 == 0:
-                print 'error', error
-
-
-def demo():
-    # Teach network XOR function
-    pat = [
-        [[0,0], [0]],
-        [[0,1], [1]],
-        [[1,0], [1]],
-        [[1,1], [0]]
-    ]
-
-    # create a network with two input, two hidden, and two output nodes
-    n = NN(2, 3, 1)
-    # train it with some patterns
-    n.train(pat, 2000)
-    # test it
-    n.test(pat)
-
-
-# __________  Entry point for stand-alone builds __________
-
-import time
-
-def entry_point(argv):
-    if len(argv) > 1:
-        N = int(argv[1])
-    else:
-        N = 200
-    T = time.time()
-    for i in range(N):
-        demo()
-    t1 = time.time() - T
-    print "%d iterations, %s milliseconds per iteration" % (N, 1000.0*t1/N)
-    return 0
-
-# _____ Define and setup target ___
-
-def target(*args):
-    return entry_point, None
-
-if __name__ == '__main__':
-    if len(sys.argv) == 1:
-        sys.argv.append('1')
-    entry_point(sys.argv)
-    print __doc__

File demo/dis-goal.py

-"""
-An old-time classical example, and one of our first goals.
-To run on top of PyPy.
-"""
-
-import dis
-dis.dis(dis.dis)

File demo/distribution/client.py

-""" This a sample client, suitable for use with server.py from this
-directory
-
-run by:
-pypy-c client.py
-"""
-
-HOST = '127.0.0.1'
-PORT = 12222
-
-from distributed.socklayer import connect
-remote_handle = connect((HOST, PORT))
-
-import code
-code.interact(local=locals())
-
-""" Things that can be done: 1. remote object access
-
-x = remote_handle.x
-assert type(x) is remote_handle.X # typecheck
-x.meth(lambda x: x + 10, 6) # remote call, with callback localy
-x.meth(remote_handle.f, 3) # remote call, remote callback
-remote_handle.sys._getframe(2).f_locals['x'] # remote frame access
-# XXX should be 'is x' and shouldn't need (2) argument
-
-# XXX next one does not work, while it should. Too much mangling with remote
-# traceback frames probably
-try:
-  x.meth(1, 2) # non-callable argument, AssertionError
-except:
-  import sys
-  e, c, tb = sys.exc_info()
-  import pdb
-  pdb.post_mortem(tb)
-"""

File demo/distribution/fileclient.py

-
-""" This is sample client for a server based in fileserver.py, not counting
-initialization, code.interact and __doc__ has just 2 lines! Usage:
-
-pypy-c fileclient.py
-
-The file_opener is a proxy for remote file object. Which means you can
-perform same operations as locally, like file_opener('/etc/passwd').read()
-or file_opener('/tmp/x', 'w').write('x')
-
-pypy-c needs to be compiled with --allworkingmodules in order to have socket
-working.
-"""
-
-HOST = '127.0.0.1'
-PORT = 12221
-
-from distributed.socklayer import connect
-file_opener = connect((HOST, PORT)).open
-
-import code
-code.interact(local=locals())
-# The file_opener is a proxy for remote file object. Which means you can
-# perform same operations as locally, like file_opener('/etc/passwd').read()
-# or file_opener('/tmp/x', 'w').write('x')

File demo/distribution/fileserver.py

-""" This is a sample demo showcasing file server, done by the pypy
-distribution library.
-
-Not counting __doc__ and initialization this is 2 line,
-fully operational file server,
-sample client which is in fileclient.py is included as well.
-
-run by:
-pypy-c fileserver.py
-
-pypy-c needs to be compiled with --allworkingmodules in order to have socket
-working.
-"""
-
-HOST = '127.0.0.1' # defaults to localhost, not to export your files
-PORT = 12221
-
-from distributed.socklayer import socket_loop
-socket_loop((HOST, PORT), {'open':open})

File demo/distribution/server.py

-""" This is a demo exposing all globals from the current process over
-socket, to be accessible remotely.
-
-run by:
-pypy-c server.py
-
-pypy-c needs to be compiled with --allworkingmodules in order to have socket
-working.
-"""
-
-# things to export
-# function
-def f(x):
-    return x + 3
-
-# class
-class X:
-    def __init__(self):
-        self.slot = 3
-    
-    def meth(self, f, arg):
-        """ Method eating callable and calling it with an argument
-        """
-        assert callable(f)
-        return f(arg)
-
-# object
-x = X()
-
-# module
-import sys
-
-# constants
-HOST = '127.0.0.1'
-PORT = 12222
-
-from distributed.socklayer import socket_loop
-socket_loop((HOST, PORT), globals())

File demo/fibonacci.py

-"""
-Thunk (a.k.a. lazy objects) in PyPy.
-To run on top of the thunk object space with the following command-line:
-
-    py.py -o thunk fibonacci.py
-
-This is a typical Functional Programming Languages demo, computing the
-Fibonacci sequence by using an infinite lazy linked list.
-"""
-
-try:
-    from __pypy__ import thunk    # only available in 'py.py -o thunk'
-except ImportError:
-    print __doc__
-    raise SystemExit(2)
-
-# ____________________________________________________________
-
-
-class ListNode:
-    def __init__(self, head, tail):
-        self.head = head   # the first element of the list
-        self.tail = tail   # the sublist of all remaining elements
-
-
-def add_lists(list1, list2):
-    """Compute the linked-list equivalent of the Python expression
-          [a+b for (a,b) in zip(list1,list2)]
-    """
-    return ListNode(list1.head + list2.head,
-                    thunk(add_lists, list1.tail, list2.tail))
-
-
-# 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
-Fibonacci = ListNode(1, ListNode(1, None))
-Fibonacci.tail.tail = thunk(add_lists, Fibonacci, Fibonacci.tail)
-
-
-if __name__ == '__main__':
-    node = Fibonacci
-    while True:
-        print node.head
-        node = node.tail

File demo/fibonacci2.py

-"""
-Lazy functions in PyPy.
-To run on top of the thunk object space with the following command-line:
-
-    py.py -o thunk fibonacci2.py
-
-This is a typical Functional Programming Languages demo, computing the
-Fibonacci sequence as nested 2-tuples.
-"""
-
-import pprint
-
-try:
-    from __pypy__ import lazy
-except ImportError:
-    print __doc__
-    raise SystemExit(2)
-
-
-@lazy
-def fibo(a, b):
-    return (a, fibo(b, a + b))
-
-
-fibonacci = fibo(1, 1)
-
-pprint.pprint(fibonacci, depth=10)

File demo/foodbill.py

-"""
-Of historical interest: we computed the food bill of our first Gothenburg
-sprint with PyPy :-)
-"""
-
-slips=[(1, 'Kals MatMarkn', 6150, 'Chutney for Curry', 'dinner Saturday'),
-       (2, 'Kals MatMarkn', 32000, 'Spaghetti, Beer', 'dinner Monday'),
-       (2, 'Kals MatMarkn', -810, 'Deposit on Beer Bottles', 'various'),
-       (3, 'Fram', 7700, 'Rice and Curry Spice', 'dinner Saturday'),
-       (4, 'Kals MatMarkn', 25000, 'Alcohol-Free Beer, sundries', 'various'),
-       (4, 'Kals MatMarkn', -1570, "Michael's toothpaste", 'none'),
-       (4, 'Kals MatMarkn', -1690, "Laura's toothpaste", 'none'),
-       (4, 'Kals MatMarkn', -720, 'Deposit on Beer Bottles', 'various'),
-       (4, 'Kals MatMarkn', -60, 'Deposit on another Beer Bottle', 'various'),
-       (5, 'Kals MatMarkn', 26750, 'lunch bread meat cheese', 'lunch Monday'),
-       (6, 'Kals MatMarkn', 15950, 'various', 'dinner Tuesday and Thursday'),
-       (7, 'Kals MatMarkn', 3650, 'Drottningsylt, etc.', 'dinner Thursday'),
-       (8, 'Kals MatMarkn', 26150, 'Chicken and Mushroom Sauce', 'dinner Wed'),
-       (8, 'Kals MatMarkn', -2490, 'Jacob and Laura -- juice', 'dinner Wed'),
-       (8, 'Kals MatMarkn', -2990, "Chicken we didn't cook", 'dinner Wednesday'),
-       (9, 'Kals MatMarkn', 1380, 'fruit for Curry', 'dinner Saturday'),
-       (9, 'Kals MatMarkn', 1380, 'fruit for Curry', 'dinner Saturday'),
-       (10, 'Kals MatMarkn', 26900, 'Jansons Frestelse', 'dinner Sunday'),
-       (10, 'Kals MatMarkn', -540, 'Deposit on Beer Bottles', 'dinner Sunday'),
-       (11, 'Kals MatMarkn', 22650, 'lunch bread meat cheese', 'lunch Thursday'),
-       (11, 'Kals MatMarkn', -2190, 'Jacob and Laura -- juice', 'lunch Thursday'),
-       (11, 'Kals MatMarkn', -2790, 'Jacob and Laura -- cereal', 'lunch Thurs'),
-       (11, 'Kals MatMarkn', -760, 'Jacob and Laura -- milk', 'lunch Thursday'),
-       (12, 'Kals MatMarkn', 18850, 'lunch bread meat cheese', 'lunch Friday'),
-       (13, 'Kals MatMarkn', 18850, 'lunch bread meat cheese', 'guestimate Sun'),
-       (14, 'Kals MatMarkn', 18850, 'lunch bread meat cheese', 'guestimate Tues'),
-       (15, 'Kals MatMarkn', 20000, 'lunch bread meat cheese', 'guestimate Wed'),
-       (16, 'Kals MatMarkn', 42050, 'grillfest', 'dinner Friday'),
-       (16, 'Kals MatMarkn', -1350, 'Deposit on Beer Bottles', 'dinner Friday'),
-       (17, 'System Bolaget', 15500, 'Cederlunds Caloric', 'dinner Thursday'),
-       (17, 'System Bolaget', 22400, '4 x Farnese Sangiovese 56SEK', 'various'),
-       (17, 'System Bolaget', 22400, '4 x Farnese Sangiovese 56SEK', 'various'),
-       (17, 'System Bolaget', 13800, '2 x Jacobs Creek 69SEK', 'various'),
-       (18, 'J and Ls winecabinet', 10800, '2 x Parrotes 54SEK', 'various'),
-       (18, 'J and Ls winecabinet', 14700, '3 x Saint Paulin 49SEK', 'various'),
-       (18, 'J and Ls winecabinet', 10400, '2 x Farnese Sangioves 52SEK',
-        'cheaper when we bought it'),
-       (18, 'J and Ls winecabinet', 17800, '2 x Le Poiane 89SEK', 'various'),
-       (18, 'J and Ls winecabinet', 9800, '2 x Something Else 49SEK', 'various'),
-       (19, 'Konsum', 26000, 'Saturday Bread and Fruit', 'Slip MISSING'),
-       (20, 'Konsum', 15245, 'Mooseburgers', 'found slip'),
-       (21, 'Kals MatMarkn', 20650, 'Grilling', 'Friday dinner'),
-       (22, 'J and Ls freezer', 21000, 'Meat for Curry, grilling', ''),
-       (22, 'J and Ls cupboard', 3000, 'Rice', ''),
-       (22, 'J and Ls cupboard', 4000, 'Charcoal', ''),
-       (23, 'Fram', 2975, 'Potatoes', '3.5 kg @ 8.50SEK'),
-       (23, 'Fram', 1421, 'Peas', 'Thursday dinner'),
-       (24, 'Kals MatMarkn', 20650, 'Grilling', 'Friday dinner'),
-       (24, 'Kals MatMarkn', -2990, 'TP', 'None'),
-       (24, 'Kals MatMarkn', -2320, 'T-Gul', 'None')
-       ]
- 
-print [t[2] for t in slips]
-print (reduce(lambda x, y: x+y, [t[2] for t in slips], 0))/900

File demo/pickle_coroutine.py

-"""
-Stackless demo.
-
-This example only works on top of a pypy-c compiled with stackless features
-and the signal module:
-
-    translate.py --stackless targetpypystandalone --withmod-signal
-
-Usage:
-
-    pypy-c pickle_coroutine.py --start demo.pickle
-
-        Start the computation.  You can interrupt it at any time by
-        pressing Ctrl-C; at this point, the state of the computing
-        coroutine is saved in demo.pickle.
-
-    pypy-c pickle_coroutine.py --resume demo.pickle
-
-        Reload the coroutine from demo.pickle and continue running it.
-        (It can be interrupted again with Ctrl-C.)
-
-This demo is documented in detail in pypy/doc/stackless.txt.
-"""
-
-try:
-    import sys, pickle, signal
-    from stackless import coroutine
-except ImportError:
-    print __doc__
-    sys.exit(2)
-
-
-def ackermann(x, y):
-    check()
-    if x == 0:
-        return y + 1
-    if y == 0:
-        return ackermann(x - 1, 1)
-    return ackermann(x - 1, ackermann(x, y - 1))
-
-# ____________________________________________________________
-
-main = coroutine.getcurrent()
-sys.setrecursionlimit(100000)
-
-interrupt_flag = False
-
-def interrupt_handler(*args):
-    global interrupt_flag
-    interrupt_flag = True
-
-def check():
-    if interrupt_flag:
-        main.switch()
-
-
-def execute(coro):
-    signal.signal(signal.SIGINT, interrupt_handler)
-    res = coro.switch()
-    if res is None and coro.is_alive:    # interrupted!
-        print "interrupted! writing %s..." % (filename,)
-        f = open(filename, 'w')
-        pickle.dump(coro, f)
-        f.close()
-        print "done"
-    else:
-        print "result:", res
-
-try:
-    operation, filename = sys.argv[1:]
-except ValueError:
-    print __doc__
-    sys.exit(2)
-
-if operation == '--start':
-    coro = coroutine()
-    coro.bind(ackermann, 3, 7)
-    print "running from the start..."
-    execute(coro)
-elif operation == '--resume':
-    print "reloading %s..." % (filename,)
-    f = open(filename)
-    coro = pickle.load(f)
-    f.close()
-    print "done, running now..."
-    execute(coro)

File demo/sharedref.py

-"""
-   This is an example usage of the 'thunk' object space of PyPy.
-   It implements transparent distributed object manipulation.
-
-   Start a server on a local port, say port 8888, with:
-
-       $ py.py -o thunk sharedref.py 8888
-       Waiting for connection on port 8888
-
-   Then start and connect a client from the same or another machine:
-
-       $ py.py -o thunk sharedref.py ip_or_name:8888
-       Connecting to ('...', 8888)
-       Ok
-       >>> l = [1,2,3]
-       >>> chan.send(l)    # send the list to the server over the connexion
-
-   On the server-side:
-
-       Connected from ('...', 1046)
-       >>> l = chan.recv()    # receive the list sent above
-       >>> l
-       [1, 2, 3]
-       >>> l.append(4)
-
-   Back on the client-side:
-
-       >>> l
-       [1, 2, 3, 4]
-
-   The list behaves like a single distributed object, which both sides can
-   modify and access without needing further explicit synchronization.
-   There is no difference between who was the original sender or receiver of
-   the object, nor between which side was originally 'server' or 'client'.
-"""
-
-import sys, marshal
-from __pypy__ import thunk, become
-from socket import *
-from select import select
-
-
-class Channel:
-
-    def __init__(self, s, serverside):
-        # invariants: a shared object 'obj' is
-        #  - either remote, and a thunk, and not a value in self.cache
-        #  - or local (or at least on "our" side of this Channel), and
-        #    then it has a corresponding key in self.cache
-        self.s = s
-        self.cache = {}
-        self.inputfifo = []
-        self.count = int(not serverside)
-
-##    def _check(self, obj):
-##        print '%s: cache=%r' % (self, self.cache.keys()),
-##        if is_thunk(obj):
-##            print 'THUNK'
-##        else:
-##            print obj
-
-    def sendraw(self, obj):
-        data = marshal.dumps(obj)
-        hdr = str(len(data))
-        hdr = '0'*(10-len(hdr)) + hdr
-        self.s.sendall(hdr + data)
-
-    def _readbytes(self, count):
-        data = ''
-        while len(data) < count:
-            t = self.s.recv(count - len(data))
-            if not t:
-                raise EOFError
-            data += t
-        return data
-
-    def recvraw(self):
-        datasize = int(self._readbytes(10))
-        data = self._readbytes(datasize)
-        return marshal.loads(data)
-
-    def send(self, obj, n=None):
-        #print 'send', n,; self._check(obj)
-        if n is None:
-            n = self.count
-            self.count += 2
-            data = (n, obj, None)
-        else:
-            data = (n, obj)
-        self.sendraw(data)
-        become(obj, thunk(self._resume, n))
-        #print 'done', n,; self._check(obj)
-
-    def recv(self):
-        obj = self.inputfifo.pop(0)
-        #print 'recv',; self._check(obj)
-        return obj
-
-    def _resume(self, n):
-        #print 'resume', n,; sys.stdout.flush()
-        assert n not in self.cache
-        self.sendraw((n,))
-        while n not in self.cache:
-            self.handle_once()
-        obj = self.cache[n]
-        #self._check(obj)
-        return obj
-
-    def handle_once(self):
-        input = self.recvraw()
-        if len(input) > 1:
-            obj = input[1]
-            self.cache[input[0]] = obj
-            if len(input) > 2:
-                self.inputfifo.append(obj)
-        else:
-            n = input[0]
-            obj = self.cache[n]
-            self.send(obj, n)
-            del self.cache[n]
-
-
-def mainloop(channels):
-    stdin = sys.stdin.fileno()
-    sockfd = [chan.s.fileno() for chan in channels]
-    while True:
-        sys.stdout.write('>>> ')
-        sys.stdout.flush()
-        while True:
-            iwtd, owtd, ewtd = select([stdin] + sockfd, [], [stdin])
-            if stdin in iwtd or stdin in ewtd: break
-            for chan in channels:
-                if chan.s.fileno() in iwtd:
-                    chan.handle_once()
-        code = raw_input()
-        if not code: break
-        try:
-            co = compile(code, '<input>', 'single')
-            exec co in globals()
-        except Exception, e:
-            print e.__class__.__name__, str(e)
-
-
-def server(port):
-    s = socket(AF_INET, SOCK_STREAM)
-    s.bind(('', port))
-    s.listen(1)
-    print 'Waiting for connection on port', port
-    s, addr = s.accept()
-    print 'Connected from', addr
-    return Channel(s, True)
-
-def client(addr):
-    s = socket(AF_INET, SOCK_STREAM)
-    print 'Connecting to', addr
-    s.connect(addr)
-    print 'Ok'
-    return Channel(s, False)
-
-
-if __name__ == '__main__':
-    try:
-        thunk, become    # only available in 'py.py -o thunk'
-    except NameError:
-        print __doc__
-        raise SystemExit(2)
-
-    channels = []
-    for a in sys.argv[1:]:
-        try:
-            port = int(a)
-        except ValueError:
-            host, port = a.split(':')
-            port = int(port)
-            chan = client((host, port))
-        else:
-            chan = server(port)
-        channels.append(chan)
-
-    try:
-        mainloop(channels)
-    finally:
-        for channel in channels:
-                channel.s.close()

File demo/tproxy/persistence.py

-"""
-
-This small example implements a basic orthogonal persistence 
-mechanism on top of PyPy's transparent proxies. 
-
-"""
-from tputil import make_proxy
-
-list_changeops = set('__iadd__ __imul__ __delitem__ __setitem__ __setattr__'
-                     '__delslice__ __setslice__ '
-                     'append extend insert pop remove reverse sort'.split())
-
-dict_changeops = set('__delitem__ __setitem__  __setattr__'
-                     'clear pop popitem setdefault update'.split())
-
-def ischangeop(operation): 
-    """ return True if this operation is a changing operation 
-        on known builtins (dicts, lists). 
-    """ 
-    if isinstance(operation.obj, list):
-        changeops = list_changeops 
-    elif isinstance(operation.obj, dict):
-        changeops = dict_changeops 
-    else:
-        return False
-    return operation.opname in changeops 
-
-def make_persistent_proxy(instance, storage): 
-    def perform(operation): 
-        res = operation.delegate()
-        if ischangeop(operation):
-            print "persisting after:", operation 
-            storage.dump(instance)
-        if res is not operation.proxyobj and isinstance(res, (dict, list)):
-            res = make_proxy(perform, obj=res)
-        return res
-    return make_proxy(perform, obj=instance) 
-
-def load(storage):
-    obj = storage.load()
-    return make_persistent_proxy(obj, storage) 
-    
-if __name__ == '__main__': 
-    import py 
-    storage = py.path.local("/tmp/dictpickle")
-    pdict = make_persistent_proxy({}, storage) 
-
-    # the code below is not aware of pdict being a proxy 
-    assert type(pdict) is dict
-    pdict['hello'] = 'world'       
-    pdict['somelist'] = []
-    del pdict 
-
-    newdict = load(storage) 
-    assert newdict == {'hello': 'world', 'somelist': []}
-    l = newdict['somelist']  
-    l.append(1)              # this triggers persisting the whole dict 
-    l.extend([2,3])          # this triggers persisting the whole dict 
-    del newdict, l 
-    
-    newdict = load(storage)
-    print newdict['somelist']   # will show [1,2,3]

File demo/tproxy/print_operations.py

-"""
-
-This example transparently intercepts and shows operations on 
-builtin objects.  Requires the "--objspace-std-withtproxy" option. 
-
-"""
-
-from tputil import make_proxy 
-
-def make_show_proxy(instance):
-    def controller(operation):
-        print "proxy sees:", operation
-        res = operation.delegate()
-        return res
-    tproxy = make_proxy(controller, obj=instance)
-    return tproxy
-
-if __name__ == '__main__':
-    mydict = make_show_proxy({}) 
-    assert type(mydict) is dict            # this looks exactly like a dict 
-    mydict['hello'] = 'world'              # will print __setitem__
-    mydict[42] = 23                        # will print __setitem__
-    assert mydict.pop('hello') == 'world'  # will print pop
-    assert mydict.popitem() == (42,23)     # will print popitem
-
-