[pypy-commit] pypy default: Remove the demo directory. It's not used (and not everything works there)
fijal
noreply at buildbot.pypy.org
Sat Dec 1 19:31:20 CET 2012
Author: Maciej Fijalkowski <fijall at gmail.com>
Branch:
Changeset: r59171:584c219d55c2
Date: 2012-12-01 10:31 -0800
http://bitbucket.org/pypy/pypy/changeset/584c219d55c2/
Log: Remove the demo directory. It's not used (and not everything works
there)
diff --git a/demo/autopath.py b/demo/autopath.py
deleted file mode 100644
--- a/demo/autopath.py
+++ /dev/null
@@ -1,2 +0,0 @@
-import sys, os
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
diff --git a/demo/bpnn.py b/demo/bpnn.py
deleted file mode 100755
--- a/demo/bpnn.py
+++ /dev/null
@@ -1,214 +0,0 @@
-#!/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 at 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__
diff --git a/demo/dis-goal.py b/demo/dis-goal.py
deleted file mode 100644
--- a/demo/dis-goal.py
+++ /dev/null
@@ -1,7 +0,0 @@
-"""
-An old-time classical example, and one of our first goals.
-To run on top of PyPy.
-"""
-
-import dis
-dis.dis(dis.dis)
diff --git a/demo/distribution/client.py b/demo/distribution/client.py
deleted file mode 100644
--- a/demo/distribution/client.py
+++ /dev/null
@@ -1,35 +0,0 @@
-""" 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)
-"""
diff --git a/demo/distribution/fileclient.py b/demo/distribution/fileclient.py
deleted file mode 100644
--- a/demo/distribution/fileclient.py
+++ /dev/null
@@ -1,25 +0,0 @@
-
-""" 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')
diff --git a/demo/distribution/fileserver.py b/demo/distribution/fileserver.py
deleted file mode 100644
--- a/demo/distribution/fileserver.py
+++ /dev/null
@@ -1,19 +0,0 @@
-""" 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})
diff --git a/demo/distribution/server.py b/demo/distribution/server.py
deleted file mode 100644
--- a/demo/distribution/server.py
+++ /dev/null
@@ -1,38 +0,0 @@
-""" 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())
diff --git a/demo/fibonacci.py b/demo/fibonacci.py
deleted file mode 100644
--- a/demo/fibonacci.py
+++ /dev/null
@@ -1,43 +0,0 @@
-"""
-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
diff --git a/demo/fibonacci2.py b/demo/fibonacci2.py
deleted file mode 100644
--- a/demo/fibonacci2.py
+++ /dev/null
@@ -1,27 +0,0 @@
-"""
-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)
-
-
- at lazy
-def fibo(a, b):
- return (a, fibo(b, a + b))
-
-
-fibonacci = fibo(1, 1)
-
-pprint.pprint(fibonacci, depth=10)
diff --git a/demo/foodbill.py b/demo/foodbill.py
deleted file mode 100644
--- a/demo/foodbill.py
+++ /dev/null
@@ -1,59 +0,0 @@
-"""
-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
diff --git a/demo/pickle_coroutine.py b/demo/pickle_coroutine.py
deleted file mode 100644
--- a/demo/pickle_coroutine.py
+++ /dev/null
@@ -1,86 +0,0 @@
-"""
-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)
diff --git a/demo/sharedref.py b/demo/sharedref.py
deleted file mode 100644
--- a/demo/sharedref.py
+++ /dev/null
@@ -1,184 +0,0 @@
-"""
- 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()
diff --git a/demo/tproxy/persistence.py b/demo/tproxy/persistence.py
deleted file mode 100644
--- a/demo/tproxy/persistence.py
+++ /dev/null
@@ -1,62 +0,0 @@
-"""
-
-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]
diff --git a/demo/tproxy/print_operations.py b/demo/tproxy/print_operations.py
deleted file mode 100644
--- a/demo/tproxy/print_operations.py
+++ /dev/null
@@ -1,26 +0,0 @@
-"""
-
-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
-
-
More information about the pypy-commit
mailing list