pdftk *.pdf cat output /tmp/foo.pdf

• When: Friday, April 28th. 7pm onwards
• Where: My Place, Mountain View, to My New Place, Sunnyvale (about 6 miles)
• Bring: muscles, friends, handy moving equipment (although I don't expect to need it, 'cause I can lift nearly everything myself...)
• I'll supply: Mostly packed stuff, drinks, pizza, limited vehicular space, etc.

1. Move stuff
2. Repeat step 1 until done, or bored
   
3. Hang out in Sunnyvale.

patrissimo

choiceful

import array
import struct

BLOCKSIZE=8192

def csviter(file, type):
    """
    Pseudo-parses a csv file with a single record and iterates over the
    columns.
    """
    return sepiter(file, ',', type)

# Turn a 4 byte binary string into a float
def unpackfloat(binstring):
    x = struct.unpack('f', binstring)
    return x[0]

def sepiter(file, sep, type,
            skip=str.isspace, blocksize=None):
    """
    Iterate over elements in file seperated by sep.
    Args:
      file: file-like object that supports .read(size)
      sep: single character seperator.
      type: function to call to create each item from a string
      skip: Filter function. If true, skips the given item.
            Applied to string value before type.
            Defaults to str.isspace.
      blocksize: how many bytes to read at once.
          Defaults to value of the global BLOCKSIZE at construction time.
    """
    assert len(sep) == 1, "sep must be a single character"
    if blocksize is None: blocksize = BLOCKSIZE
    buffer = array.array('c')
    end = None # the end of the data for the current item

    # Loop over every item in the input
    while True:

        # Fill buffer until EOF or it includes sep.
        # Return if out of buffer and out of input
        while True:
            try:
                end = buffer.index(sep)
                break
            except ValueError:
                data = file.read(blocksize)
                if not data and not buffer:
                    # Out of buffered data and file data. All done.
                    return
                if not data:
                    # EOF. Continue processing buffered data.
                    end = len(buffer)
                    break
                data.rstrip("\r\n")
                buffer.fromstring(data) # O(N) / O(N^2) faster than .extend

        # The buffer has some data in it. Pull and yield a single value.
        item = buffer[:end].tostring()
        # Erase item + sep. If array.index had a start argument, we could
        # avoid shifting the entire array here.
        buffer[:end + 1] = array.array('c')
        if not skip(item):
            yield type(item)



def biniter(file, recordsize, type, recordblocksize=None):
    """
    Iterate over fixed size records in a file.
    Args:
      file: File-like object that supports .read(size)
      recordsize: Number of bytes in a single record.
      type: Type constructor for each item.
      recordblocksize: Number of records to read from the input at a time.
          Defaults to the number of records that can fit in BLOCKSIZE rounded
          up to the next whole record. 
    """
    if recordblocksize is None:
        recordblocksize = int((BLOCKSIZE / float(recordsize))+.5)
    
    buffer = array.array('c')
    buffer_pos = 0
    blocksize = recordsize * recordblocksize
    while True:
        while len(buffer) - buffer_pos < recordsize:
            data = file.read(blocksize)
            if not data and buffer_pos >= len(buffer):
                return
            if buffer_pos == len(buffer):
                buffer_pos = 0
                buffer = array.array('c')
            elif len(buffer) > blocksize:
                buffer[:buffer_pos] = array.array('c')
                buffer_pos = 0
            if not data:
                break
            buffer.fromstring(data)
        yield type(buffer[buffer_pos:buffer_pos+recordsize].tostring())
        buffer_pos += recordsize