Adding a bunch of sample files for many different topic

Author: Jonathan Rocher

generator_illustration.py

@@ -0,0 +1,45 @@
+""" Illustrate the use of generators for large processing pipelines. 
+The pipeline involves 4 steps: identify the all files that have the 
+word 'log' in their name, open all files based on their extension, 
+process all lines in the file and retain the ones that contain python.
+"""
+
+import os
+import gzip, bz2
+
+def find_files(directory, part_name):
+    print "Searching directory %s" % directory
+    for path, directory, listfile in os.walk(directory):
+        for name in listfile:
+            if part_name in name:
+                yield os.path.join(path, name)
+
+def opener(filenames):
+    for filename in filenames:
+        ext = os.path.splitext(filename)[1]
+        if ext == ".gz":
+            f = gzip.open(filename)
+        elif ext == ".bz2":
+            f = bz2.BZ2File(filename)
+        else:
+            f = open(filename)
+        yield f
+        
+def cat(filelist):
+    for file_object in filelist:
+        for line in file_object:
+            yield line
+    
+def grep(string, lines):
+    for line in lines:
+        if string in line:
+            yield line 
+            
+            
+filenames = find_files(".", "log")
+files = opener(filenames)
+content = cat(files)
+interesting_content = grep("python", content)
+
+for line in interesting_content:
+    print line

sample_setup.py

@@ -0,0 +1,23 @@
+import os
+from setuptools import setup
+
+setup(
+    name = "foo",
+    version = "0.1",
+    author = "Enthought Inc.",
+    author_email = "info@enthought.com",
+    description = ("This is a foo package that doesn't do anything"),
+    license = "GPL",
+    packages=['dir1'],
+    long_description=""" This is a long description
+    for my package.
+    """,
+    entry_points = {
+        'console_scripts': [
+            'foo_exec = dir1.run:main',
+            ],
+        },
+    include_package_data = True,
+    data_files=["doc.html"],
+    zip_safe = False,
+)

sqlalchemy_simple_example.py

@@ -0,0 +1,41 @@
+""" Simple example of usage of sqlalchemy to illustrate common simple patterns.
+
+Source: http://www.rmunn.com/sqlalchemy-tutorial/tutorial.html
+"""
+
+from sqlalchemy import *
+
+db = create_engine('sqlite:///tutorial.db')
+
+db.echo = False  # Try changing this to True and see what happens
+
+# The metadata is a collection of tables that needs to be bound to the
+# engine
+metadata = MetaData()
+metadata.bind = db
+
+users = Table('users', metadata,
+    Column('user_id', Integer, primary_key=True),
+    Column('name', String(40)),
+    Column('age', Integer),
+    Column('password', String),
+)
+users.create()
+
+i = users.insert()
+i.execute(name='Mary', age=30, password='secret')
+i.execute({'name': 'John', 'age': 42},
+          {'name': 'Susan', 'age': 57},
+          {'name': 'Carl', 'age': 33})
+
+s = users.select()
+rs = s.execute()
+
+row = rs.fetchone()
+print 'Id:', row[0]
+print 'Name:', row['name']
+print 'Age:', row.age
+print 'Password:', row[users.c.password]
+
+for row in rs:
+    print row.name, 'is', row.age, 'years old'

stdlib/example_multiprocessing.py

@@ -0,0 +1,29 @@
+"""
+"""
+
+import multiprocessing as mp
+import sys
+from time import sleep
+
+
+def process_action(proc_num, n):
+    """ Take a child process, print its PID and sleep for n seconds
+    """
+    proc = mp.current_process()
+    proc_name = proc.name
+    proc_id = proc.pid
+    print "Child process number %s " % proc_num
+    sys.stdout.flush()
+    sleep(n)
+    print "Process %s is done" % proc_num
+    sys.stdout.flush()
+    
+if __name__ == "__main__":
+    nb_processes = 10
+    for i in range(nb_processes):
+        p = mp.Process(target=process_action, args = (i, i+10))
+        p.start()
+        
+    [p.join() for p in mp.active_children()]
+    print "Main process can keep running now that they all have joined"
+    sys.stdout.flush()

test_collections.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+from collections import *
+from timeit import timeit
+
+d = OrderedDict()
+for i, key in enumerate('abcde'):
+     d[key] = i+1
+d["A"] = 0.
+print d
+

test_hiding_properties.py

@@ -0,0 +1,29 @@
+class MyNumberB(object):
+
+    def __init__(self, number):
+
+        self._number = number
+
+
+    def number():
+
+        def _get_number(self):
+
+            return self._number
+
+        def _set_number(self, value):
+
+            if isinstance(value, basestring):
+
+                number = eval(value)
+
+            else:
+
+                number = value
+
+            self._number = number
+
+        return dict(fget=_get_number, fset=_set_number)
+
+
+    number = property(**number())

test_xml.py

@@ -0,0 +1,15 @@
+from SimpleXMLRPCServer import SimpleXMLRPCServer
+
+def fact(n):
+    if n <= 1:
+        return 1
+    else:
+        return n * fact(n-1)
+
+# Start a server listening for requests on port 8001.
+if __name__ == '__main__':
+    server = SimpleXMLRPCServer(('localhost', 8000))
+    # Register fact as a function provided by the server.
+    server.register_function(fact)
+    print "Serving the factorial function on localhost:8000..."
+    server.serve_forever()

test_xmlrpc.py

@@ -0,0 +1,21 @@
+""" XMLRPC server with a handler
+"""
+
+from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler, \
+                               SimpleXMLRPCServer
+def fact(n):
+    if n <= 1:
+        return 1
+    else:
+        return n * fact(n-1)
+    
+# Override the _dispatch() handler to call the requested function.
+class my_handler(SimpleXMLRPCRequestHandler):
+    def _dispatch(self, method, params):
+        print "CALL", method, params
+        return apply(eval(method), params)
+    
+# Start a server listening for requests on port 8001.
+if __name__ == '__main__':
+    server = SimpleXMLRPCServer(('localhost', 8001), my_handler)
+    server.serve_forever()

weave_inline.py

@@ -0,0 +1,26 @@
+""" Quick demo of weave.inline and comparing the speed of weave to pure python 
+and numpy.
+"""
+from scipy import weave
+from numpy import arange
+
+a = arange(10000.)
+
+def weave_sum(a):
+    code = """
+    double sum = 0.0;
+    for (int  i=0 ; i<Na[0]; i++)
+	       sum += a[i];
+    return_val = sum;
+    """
+    
+    return weave.inline(code, ['a'], compiler="gcc")
+
+def np_sum(a):
+    return a.sum()
+    
+def manual_sum(a):
+    total = 0.0
+    for elem in a:
+        total += elem
+    return total